Merge branch 'youngyangyang04:master' into master

problems/0112.路径总和.md

@@ -416,6 +416,8 @@ class Solution {
 Python：
 
 0112.路径总和
+
+**递归**
 ```python
 # Definition for a binary tree node.
 # class TreeNode:
@@ -424,28 +426,56 @@ Python：
 #         self.left = left
 #         self.right = right
 
-// 递归法
-
 class Solution:
     def hasPathSum(self, root: TreeNode, targetSum: int) -> bool:
-        def isornot(root,targetSum)->bool:
-            if (not root.left) and (not root.right) and targetSum == 0:return True // 遇到叶子节点，并且计数为0
-            if (not root.left) and (not root.right):return False //遇到叶子节点，计数不为0
+        def isornot(root, targetSum) -> bool:
+            if (not root.left) and (not root.right) and targetSum == 0:
+                return True  # 遇到叶子节点，并且计数为0
+            if (not root.left) and (not root.right):
+                return False  # 遇到叶子节点，计数不为0
             if root.left:
-                targetSum -= root.left.val  //左节点
-                if isornot(root.left,targetSum):return True  //递归，处理左节点
-                targetSum += root.left.val  //回溯
+                targetSum -= root.left.val  # 左节点
+                if isornot(root.left, targetSum): return True  # 递归，处理左节点
+                targetSum += root.left.val  # 回溯
             if root.right:
-                targetSum -= root.right.val //右节点
-                if isornot(root.right,targetSum):return True //递归，处理右节点
-                targetSum += root.right.val //回溯
+                targetSum -= root.right.val  # 右节点
+                if isornot(root.right, targetSum): return True  # 递归，处理右节点
+                targetSum += root.right.val  # 回溯
             return False
-            
-        if root == None:return False  //别忘记处理空TreeNode
-        else:return isornot(root,targetSum-root.val)
+
+        if root == None:
+            return False  # 别忘记处理空TreeNode
+        else:
+            return isornot(root, targetSum - root.val)
 ```
 
+**迭代 - 层序遍历**
+```python
+class Solution:
+    def hasPathSum(self, root: TreeNode, targetSum: int) -> bool:
+        if not root: 
+            return False
+
+        stack = []  # [(当前节点，路径数值), ...]
+        stack.append((root, root.val))
+
+        while stack: 
+            cur_node, path_sum = stack.pop()
+
+            if not cur_node.left and not cur_node.right and path_sum == targetSum: 
+                return True
+
+            if cur_node.right: 
+                stack.append((cur_node.right, path_sum + cur_node.right.val))    
+
+            if cur_node.left: 
+                stack.append((cur_node.left, path_sum + cur_node.left.val))
+
+        return False
+```
 0113.路径总和-ii 
+
+**递归**
 ```python
 # Definition for a binary tree node.
 # class TreeNode:
@@ -453,35 +483,36 @@ class Solution:
 #         self.val = val
 #         self.left = left
 #         self.right = right
-//递归法
 class Solution:
     def pathSum(self, root: TreeNode, targetSum: int) -> List[List[int]]:
-        path=[]
-        res=[]
-        def pathes(root,targetSum):
-            if (not root.left) and (not root.right) and targetSum == 0: // 遇到叶子节点，并且计数为0
-                res.append(path[:])  //找到一种路径，记录到res中，注意必须是path[:]而不是path
-                return 
-            if (not root.left) and (not root.right):return // 遇到叶子节点直接返回
-            if root.left:   //左
-                targetSum -= root.left.val
-                path.append(root.left.val)     //递归前记录节点
-                pathes(root.left,targetSum)    //递归
-                targetSum += root.left.val     //回溯
-                path.pop()                     //回溯
-            if root.right:  //右
-                targetSum -= root.right.val
-                path.append(root.right.val)    //递归前记录节点
-                pathes(root.right,targetSum)   //递归
-                targetSum += root.right.val    //回溯
-                path.pop()                     //回溯
-            return
-            
-        if root == None:return []             //处理空TreeNode
-        else:
-            path.append(root.val)             //首先处理根节点
-            pathes(root,targetSum-root.val)
-            return res
+
+        def traversal(cur_node, remain): 
+            if not cur_node.left and not cur_node.right and remain == 0: 
+                result.append(path[:])
+                return
+
+            if not cur_node.left and not cur_node.right: return 
+
+            if cur_node.left: 
+                path.append(cur_node.left.val)
+                remain -= cur_node.left.val
+                traversal(cur_node.left, remain)
+                path.pop()
+                remain += cur_node.left.val
+
+            if cur_node.right: 
+                path.append(cur_node.right.val)
+                remain -= cur_node.right.val
+                traversal(cur_node.right, remain)
+                path.pop()
+                remain += cur_node.right.val
+
+        result, path = [], []
+        if not root: 
+            return []
+        path.append(root.val)
+        traversal(root, targetSum - root.val)
+        return result
 ```
 
 Go：

problems/0404.左叶子之和.md

@@ -205,25 +205,51 @@ class Solution {
 
 
 Python：
-```Python
+
 **递归**
-# Definition for a binary tree node.
-# class TreeNode:
-#     def __init__(self, val=0, left=None, right=None):
-#         self.val = val
-#         self.left = left
-#         self.right = right
+```python
 class Solution:
     def sumOfLeftLeaves(self, root: TreeNode) -> int:
-        self.res=0
-        def areleftleaves(root):
-            if not root:return
-            if root.left and (not root.left.left) and (not root.left.right):self.res+=root.left.val
-            areleftleaves(root.left)
-            areleftleaves(root.right)
-        areleftleaves(root)
-        return self.res
+        if not root: 
+            return 0
+        
+        left_left_leaves_sum = self.sumOfLeftLeaves(root.left)  # 左
+        right_left_leaves_sum = self.sumOfLeftLeaves(root.right) # 右
+        
+        cur_left_leaf_val = 0
+        if root.left and not root.left.left and not root.left.right: 
+            cur_left_leaf_val = root.left.val  # 中
+            
+        return cur_left_leaf_val + left_left_leaves_sum + right_left_leaves_sum
 ```
+
+**迭代**
+```python
+class Solution:
+    def sumOfLeftLeaves(self, root: TreeNode) -> int:
+        """
+        Idea: Each time check current node's left node. 
+              If current node don't have one, skip it. 
+        """
+        stack = []
+        if root: 
+            stack.append(root)
+        res = 0
+        
+        while stack: 
+            # 每次都把当前节点的左节点加进去. 
+            cur_node = stack.pop()
+            if cur_node.left and not cur_node.left.left and not cur_node.left.right: 
+                res += cur_node.left.val
+                
+            if cur_node.left: 
+                stack.append(cur_node.left)
+            if cur_node.right: 
+                stack.append(cur_node.right)
+                
+        return res
+```
+
 Go：
 
 > 递归法

problems/0513.找树左下角的值.md

@@ -274,27 +274,51 @@ class Solution {
 
 
 Python：
+
+**递归 - 回溯**
 ```python
-//递归法
-# Definition for a binary tree node.
-# class TreeNode:
-#     def __init__(self, val=0, left=None, right=None):
-#         self.val = val
-#         self.left = left
-#         self.right = right
 class Solution:
     def findBottomLeftValue(self, root: TreeNode) -> int:
-        depth=0
-        self.res=[]
-        def level(root,depth):
-            if not root:return
-            if depth==len(self.res):
-                self.res.append([])
-                self.res[depth].append(root.val)
-            level(root.left,depth+1)
-            level(root.right,depth+1)
-        level(root,depth)
-        return self.res[-1][0]
+        max_depth = -float("INF")
+        leftmost_val = 0
+
+        def __traverse(root, cur_depth): 
+            nonlocal max_depth, leftmost_val
+            if not root.left and not root.right: 
+                if cur_depth > max_depth: 
+                    max_depth = cur_depth
+                    leftmost_val = root.val  
+            if root.left: 
+                cur_depth += 1
+                __traverse(root.left, cur_depth)
+                cur_depth -= 1
+            if root.right: 
+                cur_depth += 1
+                __traverse(root.right, cur_depth)
+                cur_depth -= 1
+
+        __traverse(root, 0)
+        return leftmost_val
+```
+**迭代 - 层序遍历**
+```python
+class Solution:
+    def findBottomLeftValue(self, root: TreeNode) -> int:
+        queue = deque()
+        if root: 
+            queue.append(root)
+        result = 0
+        while queue: 
+            q_len = len(queue)
+            for i in range(q_len): 
+                if i == 0: 
+                    result = queue[i].val 
+                cur = queue.popleft()
+                if cur.left: 
+                    queue.append(cur.left)
+                if cur.right: 
+                    queue.append(cur.right)
+        return result
 ```
 Go：
 

problems/0718.最长重复子数组.md

@@ -252,6 +252,33 @@ func findLength(A []int, B []int) int {
 }
 ```
 
+JavaScript：
+
+> 动态规划
+
+```javascript
+const findLength = (A, B) => {
+    // A、B数组的长度
+    const [m, n] = [A.length, B.length];
+    // dp数组初始化，都初始化为0
+    const dp = new Array(m + 1).fill(0).map(x => new Array(n + 1).fill(0));
+    // 初始化最大长度为0
+    let res = 0;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            // 遇到A[i - 1] === B[j - 1]，则更新dp数组
+            if (A[i - 1] === B[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            }
+            // 更新res
+            res = dp[i][j] > res ? dp[i][j] : res;
+        }
+    }
+    // 遍历完成，返回res
+    return res;
+};
+```
+
 
 
 -----------------------