udpate

Author: lazywhite

102.二叉树的层序遍历.go

@@ -41,45 +41,6 @@ func main() {
 	fmt.Println(x)
 }
 
-/*
-func levelOrder(root *TreeNode) [][]int {
-	result := make([][]int, 0)
-	if root == nil{
-		return result
-	}
-
-	queue := []*TreeNode{root}
-
-	for len(queue) > 0 {
-		size := len(queue)
-
-		levelData := make([]int, 0)
-		for i := 0; i < size; i++ {
-			// get node
-			node := queue[0] //永远取行首的node
-			// append value
-			levelData = append(levelData, node.Val)
-
-			// 每次pop一个node
-			queue = queue[1:]
-			// put children into queue
-			if node.Left != nil{
-				queue = append(queue, node.Left)
-			}
-			if node.Right != nil{
-				queue = append(queue, node.Right)
-			}
-		}
-		//queue = queue[size:]
-		if len(levelData) > 0 {
-			result = append(result, levelData)
-		}
-	}
-	return result
-
-}
-
-*/
 
 // @lc code=start
 /**

136.只出现一次的数字.go

@@ -5,9 +5,9 @@
  */
 
 /*
-1. 任何数和 00 做异或运算，结果仍然是原来的数，即 a \oplus 0=aa⊕0=a。
-2. 任何数和其自身做异或运算，结果是 00，即 a \oplus a=0a⊕a=0。
-3. 异或运算满足交换律和结合律，即 a \oplus b \oplus a=b \oplus a \oplus a=b \oplus (a \oplus a)=b \oplus0=ba⊕b⊕a=b⊕a⊕a=b⊕(a⊕a)=b⊕0=b
+1. 任何数和 0 做异或运算，结果仍然是原来的数，即 a ^ 0 = a
+2. 任何数和其自身做异或运算，结果是 0，即 a ^ a = 0
+3. 异或运算满足交换律和结合律
 */
 
 // @lc code=start

169.多数元素.go

@@ -0,0 +1,65 @@
+/*
+ * @lc app=leetcode.cn id=169 lang=golang
+ *
+ * [169] 多数元素
+ *
+ * https://leetcode-cn.com/problems/majority-element/description/
+ *
+ * algorithms
+ * Easy (66.57%)
+ * Likes:    1376
+ * Dislikes: 0
+ * Total Accepted:    487.6K
+ * Total Submissions: 732.1K
+ * Testcase Example:  '[3,2,3]'
+ *
+ * 给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
+ *
+ * 你可以假设数组是非空的，并且给定的数组总是存在多数元素。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：[3,2,3]
+ * 输出：3
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：[2,2,1,1,1,2,2]
+ * 输出：2
+ *
+ *
+ *
+ *
+ * 进阶：
+ *
+ *
+ * 尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。
+ *
+ *
+ */
+
+// @lc code=start
+// Boyer-Moore 投票算法
+func majorityElement(nums []int) int {
+	count, candidate := 0, -1
+	for i := 0; i < len(nums); i++ {
+		if count == 0 {
+			candidate = nums[i]
+		}
+
+		if nums[i] == candidate {
+			count++
+		} else {
+			count--
+		}
+	}
+
+	return candidate
+}
+
+// @lc code=end
+

2.两数相加.go

@@ -0,0 +1,66 @@
+/*
+ * @lc app=leetcode.cn id=2 lang=golang
+ *
+ * [2] 两数相加
+ */
+
+// @lc code=start
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
+
+	var (
+		head, tail *ListNode
+		carry      = 0
+	)
+
+	for l1 != nil || l2 != nil {
+		n1, n2 := 0, 0
+		if l1 != nil {
+			n1 = l1.Val
+			// 移动l1
+			l1 = l1.Next
+		}
+		if l2 != nil {
+			n2 = l2.Val
+			// 移动l2
+			l2 = l2.Next
+		}
+		sum := n1 + n2 + carry
+		left := sum % 10
+		carry = sum / 10
+
+		if head == nil {
+			// 初始化tail, head
+			head = &ListNode{
+				Val: left,
+			}
+			tail = head
+		} else {
+			node := &ListNode{
+				Val: left,
+			}
+			// 移动tail
+			tail.Next = node
+			tail = tail.Next
+		}
+	}
+
+	if carry > 0 {
+		node := &ListNode{
+			Val: carry,
+		}
+		tail.Next = node
+
+	}
+	return head
+
+}
+
+// @lc code=end
+

2192.有向无环图中一个节点的所有祖先.go

@@ -0,0 +1,50 @@
+/*
+ * @lc app=leetcode.cn id=239 lang=golang
+ *
+ * [239] 滑动窗口最大值
+ */
+// @lc code=start
+
+var a []int
+
+type hp struct{ sort.IntSlice }
+
+func (h hp) Less(i, j int) bool  { return a[h.IntSlice[i]] > a[h.IntSlice[j]] }
+func (h *hp) Push(v interface{}) { h.IntSlice = append(h.IntSlice, v.(int)) }
+func (h *hp) Pop() interface{} {
+	a := h.IntSlice
+	v := a[len(a)-1]
+	h.IntSlice = a[:len(a)-1]
+	return v
+}
+
+/*
+构造一个max heap, 队列元素存储原数组元素的index
+
+1. 每移动1位, push(j)进heap
+2. 检查heap[0]下标是否越界, 越界就执行pop()
+3. heap[0]即为当前位置最大值
+*/
+func maxSlidingWindow(nums []int, k int) []int {
+	a = nums
+	q := &hp{make([]int, k)}
+	for i := 0; i < k; i++ {
+		q.IntSlice[i] = i
+	}
+	heap.Init(q)
+
+	n := len(nums)
+	ans := make([]int, 1, n-k+1)
+	ans[0] = nums[q.IntSlice[0]]
+	for i := k; i < n; i++ {
+		heap.Push(q, i)
+		for q.IntSlice[0] <= i-k {
+			heap.Pop(q)
+		}
+		ans = append(ans, nums[q.IntSlice[0]])
+	}
+	return ans
+}
+
+// @lc code=end
+

239.滑动窗口最大值.go

@@ -29,7 +29,7 @@ func binaryTreePaths(root *TreeNode) []string {
 			return
 		}
 		current := fmt.Sprintf("%s%d->", prefix, n.Val)
-		// 到达leaf node
+		// 只有leaf node才写将自己的path放入result
 		if n.Left == nil && n.Right == nil {
 			result = append(result, current[:len(current)-2])
 		}

257.二叉树的所有路径.go

@@ -1,10 +1,3 @@
-package main
-
-func main() {
-	removeDuplicates([]int{1, 2, 2, 3, 3, 4})
-
-}
-
 /*
  * @lc app=leetcode.cn id=26 lang=golang
  *
@@ -28,30 +21,6 @@ func removeDuplicates(nums []int) int {
 	return left
 
 }
-func swap(nums []int, x, y int) {
-	nums[x], nums[y] = nums[y], nums[x]
-}
 
 // @lc code=end
 
-// 冒泡移动到最后
-func bak(nums []int) int {
-
-	size := len(nums)
-
-	// 从第2个开始向前比较
-	i := 1
-	for i < size {
-		if nums[i] == nums[i-1] {
-			// move to last
-			for j := i; j < size-1; j++ {
-				swap(nums, j, j+1)
-			}
-			// exclude last
-			size--
-		}
-		i++
-	}
-	return size
-
-}

26.删除有序数组中的重复项.go

@@ -10,10 +10,10 @@ func firstUniqChar(s string) int {
 	cache := [26]int{}
 
 	for i := range s {
-		cache[s[i]-'a']++
+		cache[s[i]-byte('a')]++
 	}
 	for i := range s {
-		if cache[s[i]-'a'] == 1 {
+		if cache[s[i]-byte('a')] == 1 {
 			return i
 		}
 	}