merge upstream

problems/0135.分发糖果.md

@@ -132,30 +132,33 @@ public:
 Java：
 ```java
 class Solution {
+    /** 
+         分两个阶段 
+         1、起点下标1 从左往右，只要 右边 比 左边 大，右边的糖果=左边 + 1
+         2、起点下标 ratings.length - 2 从右往左， 只要左边 比 右边 大，此时 左边的糖果应该 取本身的糖果数（符合比它左边大） 和 右边糖果数 + 1 二者的最大值，这样才符合 它比它左边的大，也比它右边大
+    */
     public int candy(int[] ratings) {
-        int[] candy = new int[ratings.length];
-        for (int i = 0; i < candy.length; i++) {
-            candy[i] = 1;
-        }
-
+        int[] candyVec = new int[ratings.length];
+        candyVec[0] = 1;
         for (int i = 1; i < ratings.length; i++) {
             if (ratings[i] > ratings[i - 1]) {
-                candy[i] = candy[i - 1] + 1;
+                candyVec[i] = candyVec[i - 1] + 1;
+            } else {
+                candyVec[i] = 1;
             }
         }
 
         for (int i = ratings.length - 2; i >= 0; i--) {
             if (ratings[i] > ratings[i + 1]) {
-                candy[i] = Math.max(candy[i],candy[i + 1] + 1);
+                candyVec[i] = Math.max(candyVec[i], candyVec[i + 1] + 1);
             }
         }
 
-        int count = 0;
-        for (int i = 0; i < candy.length; i++) {
-            count += candy[i];
+        int ans = 0;
+        for (int s : candyVec) {
+            ans += s;
         }
-
-        return count;
+        return ans;
     }
 }
 ```

problems/0143.重排链表.md

@@ -50,10 +50,6 @@ public:
             cur = cur->next;
             count++;
         }
-        if (vec.size() % 2 == 0) { // 如果是偶数，还要多处理中间的一个
-            cur->next = vec[i];
-            cur = cur->next;
-        }
         cur->next = nullptr; // 注意结尾
     }
 };
@@ -249,12 +245,6 @@ public class ReorderList {
             cur = cur.next;
             count++;
         }
-        // 当是偶数的话，需要做额外处理
-        if (list.size() % 2== 0){
-            cur.next = list.get(l);
-            cur = cur.next;
-        }
-
         // 注意结尾要结束一波
         cur.next = null;
     }
@@ -376,11 +366,6 @@ var reorderList = function(head, s = [], tmp) {
         cur = cur.next;
         count++;
     }
-    // 当是偶数的话，需要做额外处理
-    if(list.length % 2 == 0){
-        cur.next = list[l];
-        cur = cur.next;
-    }
     // 注意结尾要结束一波
     cur.next = null;
 }

problems/0206.翻转链表.md

@@ -164,6 +164,25 @@ class Solution {
 }
 ```
 
+```java
+// 从后向前递归
+class Solution {
+    ListNode reverseList(ListNode head) {
+        // 边缘条件判断
+        if(head == null) return null;
+        if (head.next == null) return head;
+
+        // 递归调用，翻转第二个节点开始往后的链表
+        ListNode last = reverseList(head.next);
+        // 翻转头节点与第二个节点的指向
+        head.next.next = head;
+        // 此时的 head 节点为尾节点，next 需要指向 NULL
+        head.next = null;
+        return last;
+    } 
+}
+```
+
 Python迭代法：
 ```python
 #双指针

problems/0337.打家劫舍III.md

@@ -370,46 +370,39 @@ class Solution:
 
 Go:
 
-树形DP
+动态规划
 
 ```go
-/**
- * Definition for a binary tree node.
- * type TreeNode struct {
- *     Val int
- *     Left *TreeNode
- *     Right *TreeNode
- * }
- */
 func rob(root *TreeNode) int {
-    return max(robTree(root))
+	res := robTree(root)
+	return max(res[0], res[1])
 }
-func robTree(root *TreeNode)(int,int){
-    if root==nil{
-        return 0,0
-    }
-    //获取左节点的偷的值与不偷的值
-    left0,left1:=robTree(root.Left)
-    //获取右节点的偷的值与不偷的值
-    right0,right1:=robTree(root.Right)
-    //偷
-    val1:=root.Val
-    val1+=left1+right1
-    //不偷
-    val2:=0
-    val2+=max(left0,left1)+max(right0,right1)
-    return val1,val2
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
 }
-func max(a,b int)int{
-    if a>b{
-        return a
-    }
-    return b
+
+func robTree(cur *TreeNode) []int {
+	if cur == nil {
+		return []int{0, 0}
+	}
+	// 后序遍历
+	left := robTree(cur.Left)
+	right := robTree(cur.Right)
+
+    // 考虑去偷当前的屋子
+	robCur := cur.Val + left[0] + right[0]
+    // 考虑不去偷当前的屋子
+	notRobCur := max(left[0], left[1]) + max(right[0], right[1])
+
+    // 注意顺序：0:不偷，1:去偷
+	return []int{notRobCur, robCur}
 }
 ```
 
-
-
 JavaScript：
 
 > 动态规划

problems/0416.分割等和子集.md

@@ -226,6 +226,32 @@ class Solution:
         return taraget == dp[taraget]
 ```
 Go：
+```go
+// 分割等和子集 动态规划
+// 时间复杂度O(n^2) 空间复杂度O(n)
+func canPartition(nums []int) bool {
+    sum := 0
+    for _, num := range nums {
+        sum += num
+    }
+    // 如果 nums 的总和为奇数则不可能平分成两个子集
+    if sum % 2 == 1 {
+        return false
+    }
+
+    target := sum / 2
+    dp := make([]int, target + 1)
+
+    for _, num := range nums {
+        for j := target; j >= num; j-- {
+            if dp[j] < dp[j - num] + num {
+                dp[j] = dp[j - num] + num
+            }
+        }
+    }
+    return dp[target] == target
+}
+```
 
 ```go
 func canPartition(nums []int) bool {

problems/0707.设计链表.md

@@ -282,12 +282,12 @@ Java：
 ```Java
 //单链表
 class ListNode {
-int val;
-ListNode next;
-ListNode(){}
-ListNode(int val) {
-this.val=val;
-}
+    int val;
+    ListNode next;
+    ListNode(){}
+    ListNode(int val) {
+        this.val=val;
+    }
 }
 class MyLinkedList {
     //size存储链表元素的个数

problems/0763.划分字母区间.md

@@ -88,15 +88,15 @@ Java：
 class Solution {
     public List<Integer> partitionLabels(String S) {
         List<Integer> list = new LinkedList<>();
-        int[] edge = new int[123];
+        int[] edge = new int[26];
         char[] chars = S.toCharArray();
         for (int i = 0; i < chars.length; i++) {
-            edge[chars[i] - 0] = i;
+            edge[chars[i] - 'a'] = i;
         }
         int idx = 0;
         int last = -1;
         for (int i = 0; i < chars.length; i++) {
-            idx = Math.max(idx,edge[chars[i] - 0]);
+            idx = Math.max(idx,edge[chars[i] - 'a']);
             if (i == idx) {
                 list.add(i - last);
                 last = i;

problems/0977.有序数组的平方.md

@@ -27,7 +27,7 @@
 
 ## 暴力排序
 
-最直观的相反，莫过于：每个数平方之后，排个序，美滋滋，代码如下：
+最直观的想法，莫过于：每个数平方之后，排个序，美滋滋，代码如下：
 
 ```CPP
 class Solution {

problems/1002.查找常用字符.md

@@ -224,32 +224,28 @@ javaScript
 var commonChars = function (words) {
 	let res = []
 	let size = 26
-	let firstHash = new Array(size)
-	for (let i = 0; i < size; i++) { // 初始化 hash 数组
-		firstHash[i] = 0
-	}
+	let firstHash = new Array(size).fill(0)   // 初始化 hash 数组
 
 	let a = "a".charCodeAt()
 	let firstWord = words[0]
 	for (let i = 0; i < firstWord.length; i++) { // 第 0 个单词的统计
 		let idx = firstWord[i].charCodeAt()
 		firstHash[idx - a] += 1
 	}
-
+
+	let otherHash = new Array(size).fill(0)    // 初始化 hash 数组
 	for (let i = 1; i < words.length; i++) { // 1-n 个单词统计
-		let otherHash = new Array(size)
-		for (let i = 0; i < size; i++) { // 初始化 hash 数组
-			otherHash[i] = 0
-		}
-
 		for (let j = 0; j < words[i].length; j++) {
 			let idx = words[i][j].charCodeAt()
 			otherHash[idx - a] += 1
 		}
+
 		for (let i = 0; i < size; i++) {
 			firstHash[i] = Math.min(firstHash[i], otherHash[i])
 		}
+		otherHash.fill(0)
 	}
+
 	for (let i = 0; i < size; i++) {
 		while (firstHash[i] > 0) {
 			res.push(String.fromCharCode(i + a))

problems/剑指Offer58-II.左旋转字符串.md

@@ -200,17 +200,14 @@ func reverse(b []byte, left, right int){
 JavaScript：
 
 ```javascript
-var reverseLeftWords = function (s, n) {
-    const reverse = (str, left, right) => {
-        let strArr = str.split("");
-        for (; left < right; left++, right--) {
-            [strArr[left], strArr[right]] = [strArr[right], strArr[left]];
-        }
-        return strArr.join("");
-    }
-    s = reverse(s, 0, n - 1);
-    s = reverse(s, n, s.length - 1);
-    return reverse(s, 0, s.length - 1);
+var reverseLeftWords = function(s, n) {
+  const length = s.length;
+  let i = 0;
+  while (i < length - n) {
+    s = s[length - 1] + s;
+    i++;
+  }
+  return s.slice(0, length);
 };
 ```
 

problems/周总结/20200927二叉树周末总结.md

@@ -51,8 +51,8 @@ morris遍历是二叉树遍历算法的超强进阶算法，morris遍历可以
 在[二叉树：一入递归深似海，从此offer是路人](https://programmercarl.com/二叉树的递归遍历.html)中讲到了递归三要素，以及前中后序的递归写法。
 
 文章中我给出了leetcode上三道二叉树的前中后序题目，但是看完[二叉树：一入递归深似海，从此offer是路人](https://programmercarl.com/二叉树的递归遍历.html)，依然可以解决n叉树的前后序遍历，在leetcode上分别是
-* 589. N叉树的前序遍历
-* 590. N叉树的后序遍历
+* [589. N叉树的前序遍历](https://leetcode-cn.com/problems/n-ary-tree-preorder-traversal/)
+* [590. N叉树的后序遍历](https://leetcode-cn.com/problems/n-ary-tree-postorder-traversal/)
 
 大家可以再去把这两道题目做了。