update

Author: lazywhite

100.相同的树.go

@@ -14,9 +14,11 @@
  * }
  */
 func isSameTree(p *TreeNode, q *TreeNode) bool {
+	// 全部为nil
 	if p == nil && q == nil {
 		return true
 	}
+	// 其中一个为nil
 	if p == nil || q == nil {
 		return false
 	}

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

@@ -65,12 +65,7 @@ func levelOrder(root *TreeNode) [][]int {
 		for i := 0; i < size; i++ {
 			// get node
 			node := queue[i]
-			// 如果没做nil值过滤, 这里需要加
-			/*
-				if node == nil {
-					continue
-				}
-			*/
+
 			// append value
 			levelData = append(levelData, node.Val)
 
@@ -82,7 +77,6 @@ func levelOrder(root *TreeNode) [][]int {
 			if node.Right != nil {
 				queue = append(queue, node.Right)
 			}
-			// queue = append(queue, node.Left, node.Right)
 		}
 		// 最后整体pop
 		queue = queue[size:]

111.二叉树的最小深度.go

@@ -45,13 +45,6 @@ func minDepth(root *TreeNode) int {
 	return count
 }
 
-func min(x, y int) int {
-	if x < y {
-		return x
-	}
-	return y
-}
-
 // @lc code=end
 
 // 深度优先
@@ -70,4 +63,11 @@ func minDepth(root *TreeNode) int {
 		minD = min(minDepth(root.Right), minD)
 	}
 	return minD + 1
+}
+
+func min(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
 }

112.路径总和.go

@@ -17,24 +17,24 @@ func hasPathSum(root *TreeNode, targetSum int) bool {
 	if root == nil {
 		return false
 	}
-	return has(root, targetSum, 0)
-}
-
-func has(node *TreeNode, targetSum, parentSum int) bool {
-	curVal := parentSum + node.Val
+	var has func(*TreeNode, int) bool
+	has = func(node *TreeNode, parentSum int) bool {
+		curVal := parentSum + node.Val
 
-	if node.Left == nil && node.Right == nil {
-		return curVal == targetSum
-	}
+		if node.Left == nil && node.Right == nil {
+			return curVal == targetSum
+		}
 
-	leftHas, rightHas := false, false
-	if node.Left != nil {
-		leftHas = has(node.Left, targetSum, curVal)
-	}
-	if node.Right != nil {
-		rightHas = has(node.Right, targetSum, curVal)
+		leftHas, rightHas := false, false
+		if node.Left != nil {
+			leftHas = has(node.Left, curVal)
+		}
+		if node.Right != nil {
+			rightHas = has(node.Right, curVal)
+		}
+		return leftHas || rightHas
 	}
-	return leftHas || rightHas
+	return has(root, 0)
 }
 
 // @lc code=end

141.环形链表.go

@@ -20,19 +20,22 @@ func hasCycle(head *ListNode) bool {
 	}
 
 	slow := head
-	fast := head.Next
+	fast := head
 
-	for slow != fast {
+	for fast != nil {
 		// 因为fast肯定最先达到nil, 因此可以不判断slow
-		//if slow == nil || fast == nil || fast.Next == nil {
-		if fast == nil || fast.Next == nil {
+		// fast已经到达了末尾, 说明无环
+		if fast.Next == nil {
 			return false
 		}
 		slow = slow.Next
 		fast = fast.Next.Next
-	}
-	return true
 
+		if fast == slow {
+			return true
+		}
+	}
+	return false
 }
 
 // @lc code=end

146.lru-缓存.go

@@ -38,6 +38,12 @@ type LRUCache struct {
 	Cache    map[int]*Node
 }
 
+/*
+	1. hashtable缓存
+	2. 双向链表
+	3. 最新访问过的, 放在tail
+	4. 超出capacity, 删掉head
+*/
 func Constructor(capacity int) LRUCache {
 	head := NewNode(-1, 0)
 	tail := NewNode(-100, 0)
@@ -60,16 +66,6 @@ func NewNode(key, value int) *Node {
 	}
 }
 
-// 如果不存在返回-1, 存在需要将其放在tail
-func (this *LRUCache) Get(key int) int {
-	n, ok := this.Cache[key]
-	if !ok {
-		return -1
-	}
-	this.move2Tail(n)
-	return n.Value
-}
-
 // 首先将其从原位置删除, 然后添加到tail
 func (this *LRUCache) move2Tail(n *Node) {
 	this.removeNode(n)
@@ -91,6 +87,16 @@ func (this *LRUCache) removeNode(n *Node) {
 	n.Next.Pre = n.Pre
 }
 
+// 如果不存在返回-1, 存在需要将其放在tail
+func (this *LRUCache) Get(key int) int {
+	n, ok := this.Cache[key]
+	if !ok {
+		return -1
+	}
+	this.move2Tail(n)
+	return n.Value
+}
+
 func (this *LRUCache) Put(key int, value int) {
 	// 如果已存在, 需要更新其value, 然后移动到tail
 	if n, ok := this.Cache[key]; ok {

160.相交链表.go

@@ -34,10 +34,9 @@ func getIntersectionNode(headA, headB *ListNode) *ListNode {
 	}
 	p1, p2 := headA, headB
 
-	//最差的情况, 两个指针都走了m+n个node,
-	// 相交部分为c
-	// 1. 如果不相交, 两者均为nil
-	// 2. 如果相交, 两者会在第一个交点相遇
+	//
+	// 1. 如果不相交, 两个指针都走了m+n个node, 最终均为nil
+	// 2. 如果相交, 两者会在第一个交点相遇, 相交部分为c, 则二者均走过m+n-c
 	for p1 != p2 {
 		if p1 == nil {
 			p1 = headB

191.位-1-的个数.go

@@ -1,5 +1,3 @@
-package main
-
 /*
  * @lc app=leetcode.cn id=191 lang=golang
  *
@@ -11,11 +9,9 @@ package main
 func hammingWeight(num uint32) int {
 	count := 0
 
-	for i := 0; i < 32; i++ {
-		// 第i位为1, 结果才大于0
-		if 1<<i&num > 0 {
-			count++
-		}
+	for num > 0 {
+		num &= (num -1)
+		count++
 	}
 	return count
 }

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

@@ -6,19 +6,23 @@
 
 // @lc code=start
 func removeDuplicates(nums []int) int {
-	size := len(nums)
-	if size < 2 {
-		return size
-	}
-	left := 1
-	for right := 1; right < size; right++ {
-		if nums[right] != nums[right-1] {
-			// 直接用right值覆盖left
-			nums[left] = nums[right]
-			left++
+	left, right := 0, 1
+
+	for right < len(nums) {
+		if nums[left] != nums[right] {
+			if left != right {
+				nums[left+1] = nums[right]
+				left++
+			} else {
+				left++
+			}
 		}
+
+		right++
+
 	}
-	return left
+	// need size not index
+	return left + 1
 
 }
 

27.移除元素.go

@@ -8,20 +8,20 @@
 // 双指针法, 将等于val的值全部移动到右面
 func removeElement(nums []int, val int) int {
 
-	// 存储第一个值为val的index
-	slowIdx := 0
+	left, right := 0, 0
 
-	for fastIdx := 0; fastIdx < len(nums); fastIdx++ {
-		if nums[fastIdx] != val {
-			if slowIdx != fastIdx {
-				swap(nums, slowIdx, fastIdx)
+	for right < len(nums) {
+		if nums[right] != val {
+			if left == right {
+				left++
+			} else {
+				swap(nums, left, right)
+				left++
 			}
-			// 可能连续多个item都为val, 因此只能加1
-			slowIdx++
 		}
+		right++
 	}
-	nums = nums[:slowIdx]
-	return slowIdx
+	return left
 }
 
 func swap(arr []int, i, j int) {