Merge branch 'youngyangyang04:master' into master

problems/0055.跳跃游戏.md

@@ -122,6 +122,24 @@ class Solution:
 ```
 
 Go：
+```Go
+func canJUmp(nums []int) bool {
+	if len(nums)<=1{
+		return true
+	}
+	dp:=make([]bool,len(nums))
+	dp[0]=true
+	for i:=1;i<len(nums);i++{
+		for j:=i-1;j>=0;j--{
+			if dp[j]&&nums[j]+j>=i{
+				dp[i]=true
+				break
+			}
+		}
+	}
+	return dp[len(nums)-1]
+}
+```
 
 
 

problems/0111.二叉树的最小深度.md

@@ -302,6 +302,53 @@ class Solution:
 Go：
 
 
+JavaScript:
+
+递归法：
+
+```javascript
+/**
+    * @param {TreeNode} root
+    * @return {number}
+    */
+var minDepth1 = function(root) {
+    if(!root) return 0;
+    // 到叶子节点 返回 1
+    if(!root.left && !root.right) return 1;
+    // 只有右节点时 递归右节点
+    if(!root.left) return 1 + minDepth(root.right);、
+    // 只有左节点时 递归左节点
+    if(!root.right) return 1 + minDepth(root.left);
+    return Math.min(minDepth(root.left), minDepth(root.right)) + 1;
+};
+```
+
+迭代法：
+
+```javascript
+/**
+* @param {TreeNode} root
+* @return {number}
+*/
+var minDepth = function(root) {
+    if(!root) return 0;
+    const queue = [root];
+    let dep = 0;
+    while(true) {
+        let size = queue.length;
+        dep++;
+        while(size--){
+            const node = queue.shift();
+            // 到第一个叶子节点 返回 当前深度 
+            if(!node.left && !node.right) return dep;
+            node.left && queue.push(node.left);
+            node.right && queue.push(node.right);
+        }
+    }
+};
+```
+
+
 
 
 -----------------------

problems/0383.赎金信.md

@@ -136,7 +136,34 @@ class Solution {
 ```
 
 Python：
+```
+class Solution(object):
+    def canConstruct(self, ransomNote, magazine):
+        """
+        :type ransomNote: str
+        :type magazine: str
+        :rtype: bool
+        """
         
+        # use a dict to store the number of letter occurance in ransomNote
+        hashmap = dict()
+        for s in ransomNote:
+            if s in hashmap:
+                hashmap[s] += 1
+            else:
+                hashmap[s] = 1
+        
+        # check if the letter we need can be found in magazine
+        for l in magazine:
+            if l in hashmap:
+                hashmap[l] -= 1
+        
+        for key in hashmap:
+            if hashmap[key] > 0:
+                return False
+        
+        return True
+```
 
 Go：
 

problems/0454.四数相加II.md

@@ -121,6 +121,37 @@ class Solution {
 
 Python：
 
+```
+class Solution(object):
+    def fourSumCount(self, nums1, nums2, nums3, nums4):
+        """
+        :type nums1: List[int]
+        :type nums2: List[int]
+        :type nums3: List[int]
+        :type nums4: List[int]
+        :rtype: int
+        """
+        # use a dict to store the elements in nums1 and nums2 and their sum
+        hashmap = dict()
+        for n1 in nums1:
+            for n2 in nums2:
+                if n1 + n2 in hashmap:
+                    hashmap[n1+n2] += 1
+                else:
+                    hashmap[n1+n2] = 1
+        
+        # if the -(a+b) exists in nums3 and nums4, we shall add the count
+        count = 0
+        for n3 in nums3:
+            for n4 in nums4:
+                key = - n3 - n4
+                if key in hashmap:
+                    count += hashmap[key]
+        return count
+                
+
+```
+
 
 Go：
 

problems/0516.最长回文子序列.md

@@ -175,36 +175,35 @@ Python：
 Go：
 ```Go
 func longestPalindromeSubseq(s string) int {
-    str:=[]byte(s)
-    dp:=make([][]int,len(s))
-    for i:=0;i<len(s);i++{
-        dp[i]=make([]int,len(s))
+	lenth:=len(s)
+	dp:=make([][]int,lenth)
+	for i:=0;i<lenth;i++{
+		for j:=0;j<lenth;j++{
+			if dp[i]==nil{
+				dp[i]=make([]int,lenth)
 			}
-    for i:=1;i<len(s);i++{
-        for j:=i-1;j>=0;j--{
-            if str[i]==str[j]{
-                if j==i-1{
-                    dp[j][i]=2
-                }else{
-                    dp[j][i]=dp[j+1][i-1]+2
-                }
-            }else{
-                dp[j][i]=Max(dp[j+1][i],dp[j][i-1])
+			if i==j{
+				dp[i][j]=1
 			}
 		}
 	}
-    return dp[0][len(s)-1]
-}
-func Max(a,b int)int{
-    if a>b{
-        return a
+	for i:=lenth-1;i>=0;i--{
+		for j:=i+1;j<lenth;j++{
+			if s[i]==s[j]{
+				dp[i][j]=dp[i+1][j-1]+2
+			}else {
+				dp[i][j]=max(dp[i+1][j],dp[i][j-1])
 			}
-    return b
+		}
+	}
+
+	return dp[0][lenth-1]
 }
 ```
 
 
 
+
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)

problems/0530.二叉搜索树的最小绝对差.md

@@ -177,8 +177,29 @@ 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 getMinimumDifference(self, root: TreeNode) -> int:
+        res = []   
+        r = float("inf")
+        def buildaList(root):  //把二叉搜索树转换成有序数组
+            if not root: return None
+            if root.left: buildaList(root.left)  //左
+            res.append(root.val)  //中
+            if root.right: buildaList(root.right)  //右
+            return res
             
-
+        buildaList(root)
+        for i in range(len(res)-1):  // 统计有序数组的最小差值
+            r = min(abs(res[i]-res[i+1]),r)
+        return r
+```
 Go：
 
 

problems/二叉树的迭代遍历.md

@@ -160,11 +160,175 @@ Java：
 
 
 Python：
+```python3
+# 前序遍历-迭代-LC144_二叉树的前序遍历
+class Solution:
+    def preorderTraversal(self, root: TreeNode) -> List[int]:
+        # 根结点为空则返回空列表
+        if not root:
+            return []
+        stack = [root]
+        result = []
+        while stack:
+            node = stack.pop()
+            # 中结点先处理
+            result.append(node.val)
+            # 右孩子先入栈
+            if node.right:
+                stack.append(node.right)
+            # 左孩子后入栈
+            if node.left:
+                stack.append(node.left)
+        return result
+        
+# 中序遍历-迭代-LC94_二叉树的中序遍历
+class Solution:
+    def inorderTraversal(self, root: TreeNode) -> List[int]:
+        if not root:
+            return []
+        stack = []  # 不能提前将root结点加入stack中
+        result = []
+        cur = root
+        while cur or stack:
+            # 先迭代访问最底层的左子树结点
+            if cur:     
+                stack.append(cur)
+                cur = cur.left		
+            # 到达最左结点后处理栈顶结点    
+            else:		
+                cur = stack.pop()
+                result.append(cur.val)
+                # 取栈顶元素右结点
+                cur = cur.right	
+        return result
+        
+# 后序遍历-迭代-LC145_二叉树的后序遍历
+class Solution:
+    def postorderTraversal(self, root: TreeNode) -> List[int]:
+        if not root:
+            return []
+        stack = [root]
+        result = []
+        while stack:
+            node = stack.pop()
+            # 中结点先处理
+            result.append(node.val)
+            # 左孩子先入栈
+            if node.left:
+                stack.append(node.left)
+            # 右孩子后入栈
+            if node.right:
+                stack.append(node.right)
+        # 将最终的数组翻转
+        return result[::-1]
+```
 
 
 Go：
+> 迭代法前序遍历
 
+```go
+//迭代法前序遍历
+/**
+ type Element struct {
+    // 元素保管的值
+    Value interface{}
+    // 内含隐藏或非导出字段
+}
 
+func (l *List) Back() *Element 
+前序遍历：中左右
+压栈顺序：右左中
+ **/
+func preorderTraversal(root *TreeNode) []int {
+	if root == nil {
+		return nil
+	}
+	var stack = list.New()
+    stack.PushBack(root.Right)
+    stack.PushBack(root.Left)
+    res:=[]int{}
+    res=append(res,root.Val)
+    for stack.Len()>0 {
+        e:=stack.Back()
+        stack.Remove(e)
+        node := e.Value.(*TreeNode)//e是Element类型，其值为e.Value.由于Value为接口，所以要断言
+        if node==nil{
+            continue
+        }
+        res=append(res,node.Val)
+        stack.PushBack(node.Right)
+        stack.PushBack(node.Left)
+    }
+    return res
+}
+```
+
+> 迭代法后序遍历
+
+```go
+//迭代法后序遍历
+//后续遍历：左右中
+//压栈顺序：中右左(按照前序遍历思路)，再反转结果数组
+func postorderTraversal(root *TreeNode) []int {
+	if root == nil {
+		return nil
+	}
+	var stack = list.New()
+    stack.PushBack(root.Left)
+    stack.PushBack(root.Right)
+    res:=[]int{}
+    res=append(res,root.Val)
+    for stack.Len()>0 {
+        e:=stack.Back()
+        stack.Remove(e)
+        node := e.Value.(*TreeNode)//e是Element类型，其值为e.Value.由于Value为接口，所以要断言
+        if node==nil{
+            continue
+        }
+        res=append(res,node.Val)
+        stack.PushBack(node.Left)
+        stack.PushBack(node.Right)
+    }
+    for i:=0;i<len(res)/2;i++{
+        res[i],res[len(res)-i-1] = res[len(res)-i-1],res[i]
+    }
+    return res
+}
+```
+
+> 迭代法中序遍历
+
+```go
+//迭代法中序遍历
+func inorderTraversal(root *TreeNode) []int {
+    rootRes:=[]int{}
+    if root==nil{
+       return nil
+    }
+    stack:=list.New()
+    node:=root
+    //先将所有左节点找到，加入栈中
+    for node!=nil{
+        stack.PushBack(node)
+        node=node.Left
+    }
+    //其次对栈中的每个节点先弹出加入到结果集中，再找到该节点的右节点的所有左节点加入栈中
+    for stack.Len()>0{
+        e:=stack.Back()
+        node:=e.Value.(*TreeNode)
+        stack.Remove(e)
+        //找到该节点的右节点，再搜索他的所有左节点加入栈中
+        rootRes=append(rootRes,node.Val)
+        node=node.Right
+        for node!=nil{
+            stack.PushBack(node)
+            node=node.Left
+        }
+    }
+    return rootRes
+}
+```
 
 
 -----------------------