Merge pull request #32 from v1xingyue/master

BJ001-1904007-第一周算法作业-第一次提交

Author: GeekUniversity

Week_01/id_7/LeetCode_136_7.go

@@ -0,0 +1,50 @@
+package geekcode
+
+/*
+https://leetcode-cn.com/problems/single-number/
+
+给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
+
+说明：
+
+你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
+
+示例 1:
+
+输入: [2,2,1]
+输出: 1
+示例 2:
+
+输入: [4,1,2,1,2]
+输出: 4
+
+
+因为抑或满足交换律，所以， 乱序 也可以随意交换，
+把两个相同的放在一起，抑或为 0 ,
+最后剩下多余的那个数字，就是出现一次的数字
+*/
+
+func singleNumber(nums []int) int {
+	num := 0
+	for _, v := range nums {
+		num = num ^ v
+	}
+	return num
+}
+
+/***
+func singleNumber(nums []int) int {
+    hashnums := make(map[int]int)
+    for k,v := range nums {
+        if  _,ok := hashnums[v] ; ok {
+            delete(hashnums,v)
+        }else {
+            hashnums[v] = k
+        }
+    }
+    for idx,_ := range(hashnums) {
+        return idx
+    }
+    return -1
+}
+**/

Week_01/id_7/LeetCode_1_7.go

@@ -0,0 +1,37 @@
+package geekcode
+
+/*
+https://leetcode-cn.com/problems/two-sum/
+
+给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
+
+你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
+
+示例:
+
+给定 nums = [2, 7, 11, 15], target = 9
+
+因为 nums[0] + nums[1] = 2 + 7 = 9
+所以返回 [0, 1]
+
+*/
+
+func twoSum(nums []int, target int) []int {
+	l := len(nums)
+	hashNums := make(map[int]int)
+
+	// 如果一个数字是解，那么最多出现两次
+	for i := 0; i < l; i++ {
+		hashNums[nums[i]] = i
+	}
+
+	for i := 0; i < l-1; i++ {
+
+		if idx, ok := hashNums[target-nums[i]]; ok && idx != i {
+			return []int{i, idx}
+		}
+
+	}
+	return nil
+
+}

Week_01/id_7/LeetCode_20_7.go

@@ -0,0 +1,132 @@
+package geekcode
+
+/*
+https://leetcode-cn.com/problems/valid-parentheses/
+给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
+
+有效字符串需满足：
+
+左括号必须用相同类型的右括号闭合。
+左括号必须以正确的顺序闭合。
+注意空字符串可被认为是有效字符串。
+
+示例 1:
+
+输入: "()"
+输出: true
+示例 2:
+
+输入: "()[]{}"
+输出: true
+示例 3:
+
+输入: "(]"
+输出: false
+示例 4:
+
+输入: "([)]"
+输出: false
+示例 5:
+
+输入: "{[]}"
+输出: true
+
+*/
+
+// 用单链表来实现一个简单的栈，
+// push 操作为队尾添加元素
+// pop 操作为从队尾获取元素，前边的元素的next 指向nil
+// 判断是否为空 ， 判断 last 指向的元素是否为nil
+// 考虑到单链表操作，如果从队尾删除数据 即 pop 操作，查找pre 元素，复杂度较高，所以，采用头插法实现链表插入操作
+// 不要担心 last 指针为空，着急改变last 的指向，第一个节点的next 为nil 正好表示栈为空
+
+//链表实现的一个栈
+//默认最大元素个数为2048
+type Node struct {
+	val  rune
+	next *Node
+}
+
+//栈类型
+type Stack struct {
+	head *Node
+	size int
+	max  int
+}
+
+//初始化栈,不使用大小参数
+func NewStack() *Stack {
+	s := new(Stack)
+	s.size = 0
+	s.max = 2048
+	return s
+}
+
+// 大小控制，默认可以装2048个元素,可以传递大小参数
+func NewStackWithSize(max int) *Stack {
+	s := new(Stack)
+	s.size = 0
+	s.max = max
+	return s
+}
+
+//push 操作注意，头指针的next 指针变动
+//遍历结果，从head 指针往next 遍历即可完成操作
+//超过最大的size ，则入栈失败
+func (self *Stack) Push(c rune) bool {
+	if self.size >= self.max {
+		return false
+	}
+	self.size++
+	self.head = &Node{val: c, next: self.head}
+	return true
+}
+
+//出栈操作，直接获取头指针，然后改变头指针为头指针的下一个结点
+func (self *Stack) Pop() rune {
+	if self.head == nil {
+		return 0
+	}
+	b := self.head.val
+	self.head = self.head.next
+	self.size--
+	return b
+}
+
+//返回当前栈内的元素个数
+func (self *Stack) Count() int {
+	return self.size
+}
+
+//检查栈是否为空
+func (self *Stack) IsEmpty() bool {
+	return self.size == 0
+}
+
+//检查括号字符串匹配
+func isValid(s string) bool {
+	stack := NewStack()
+	var last rune
+	for _, v := range s {
+		switch v {
+		case '(', '[', '{':
+			stack.Push(v)
+		case ')':
+			last = stack.Pop()
+			if last != '(' {
+				return false
+			}
+		case ']':
+			last = stack.Pop()
+			if last != '[' {
+				return false
+			}
+		case '}':
+			last = stack.Pop()
+			if last != '{' {
+				return false
+			}
+		}
+	}
+	return stack.IsEmpty()
+}

Week_01/id_7/LeetCode_21_7.go

@@ -0,0 +1,133 @@
+package geekcode
+
+// 题目地址: https://leetcode-cn.com/problems/merge-two-sorted-lists/
+// 合并两个有序链表
+//将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
+//
+//示例：
+//
+//输入：1->2->4, 1->3->4
+//输出：1->1->2->3->4->4
+//
+
+import (
+	"log"
+)
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+/**
+* 打印list 类型，方便查看list的结果
+ */
+func PrintList(list *ListNode) {
+	l := list
+	for l != nil {
+		log.Println(l.Val)
+		l = l.Next
+	}
+}
+
+/**
+* 初始化列表
+* 使用一个数组初始化
+ */
+func InitList(nums []int) *ListNode {
+	h := new(ListNode)
+	l := h
+	for _, v := range nums {
+		l.Next = &ListNode{Val: v, Next: nil}
+		l = l.Next
+	}
+	return h.Next
+}
+
+/**
+* Definition for singly-linked list.
+* type ListNode struct {
+*     Val int
+*     Next *ListNode
+* }
+*
+ 8 ms, 2.8 MB,
+*/
+func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
+
+	if l1 == nil {
+		return l2
+	}
+
+	if l2 == nil {
+		return l1
+	}
+
+	p0, p1 := l1, l2
+	nList := new(ListNode)
+	p2 := nList
+
+	for p0 != nil || p1 != nil {
+		switch {
+		case p0 == nil:
+			nList.Next = &ListNode{Val: p1.Val, Next: nil}
+			p1 = p1.Next
+		case p1 == nil:
+			nList.Next = &ListNode{Val: p0.Val, Next: nil}
+			p0 = p0.Next
+		default:
+			if p0.Val <= p1.Val {
+				nList.Next = &ListNode{Val: p0.Val, Next: nil}
+				p0 = p0.Next
+			} else {
+				nList.Next = &ListNode{Val: p1.Val, Next: nil}
+				p1 = p1.Next
+			}
+		}
+
+		nList = nList.Next
+	}
+	return p2.Next
+}
+
+/*
+* 修改版本，减少内存消耗
+* 4ms ,  2.5 MB
+ */
+func mergeTwoLists2(l1 *ListNode, l2 *ListNode) *ListNode {
+
+	if l1 == nil {
+		return l2
+	}
+
+	if l2 == nil {
+		return l1
+	}
+
+	p0, p1 := l1, l2
+	nList := new(ListNode)
+	p2 := nList
+
+	for p0 != nil || p1 != nil {
+		switch {
+		case p0 == nil:
+			nList.Next = p1
+			p1 = p1.Next
+		case p1 == nil:
+			nList.Next = p0
+			p0 = p0.Next
+		default:
+			if p0.Val <= p1.Val {
+				nList.Next = p0
+				p0 = p0.Next
+			} else {
+				nList.Next = p1
+				p1 = p1.Next
+			}
+		}
+
+		nList = nList.Next
+	}
+	return p2.Next
+
+}

Week_01/id_7/NOTE.md

@@ -1 +1,25 @@
-# 学习笔记
+# 学习笔记
+
+* 合并两个有序链表:
+
+[https://leetcode-cn.com/problems/merge-two-sorted-lists/](https://leetcode-cn.com/problems/merge-two-sorted-lists/)
+
+[merge-two-sorted-lists.go](merge-two-sorted-lists.go)
+
+* 只出现一次的数字:
+
+[https://leetcode-cn.com/problems/single-number/](https://leetcode-cn.com/problems/single-number/)
+
+[single-number.go](single-number.go)
+
+* 两数之和等于指定数字:
+
+[https://leetcode-cn.com/problems/two-sum/](https://leetcode-cn.com/problems/two-sum/)
+
+[two-sum.go](two-sum.go)
+
+* 合法的括号:
+
+[https://leetcode-cn.com/problems/valid-parentheses/](https://leetcode-cn.com/problems/valid-parentheses/)
+
+[valid-parentheses.go](valid-parentheses.go)