diff --git a/problems/0015.三数之和.md b/problems/0015.三数之和.md
index 811fc316..4f4ec63a 100644
--- a/problems/0015.三数之和.md
+++ b/problems/0015.三数之和.md
@@ -336,6 +336,23 @@ var threeSum = function(nums) {
 ```
 
 
+ruby:
+```ruby
+def is_valid(strs)
+    symbol_map = {')' => '(', '}' => '{', ']' => '['}
+    stack = []
+    strs.size.times {|i|
+        c = strs[i]
+        if symbol_map.has_key?(c)
+            top_e = stack.shift
+            return false if symbol_map[c] != top_e
+        else
+            stack.unshift(c)
+        end
+    }
+    stack.empty?
+end
+```
 
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md
index 7d2fe97e..52735794 100644
--- a/problems/0019.删除链表的倒数第N个节点.md
+++ b/problems/0019.删除链表的倒数第N个节点.md
@@ -112,6 +112,30 @@ class Solution {
     }
 }
 ```
+
+Python:
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
+        head_dummy = ListNode()
+        head_dummy.next = head
+
+        slow, fast = head_dummy, head_dummy
+        while(n!=0): #fast先往前走n步
+            fast = fast.next
+            n -= 1
+        while(fast.next!=None):
+            slow = slow.next
+            fast = fast.next
+        #fast 走到结尾后，slow的下一个节点为倒数第N个节点
+        slow.next = slow.next.next #删除
+        return head_dummy.next
+```
 Go:
 ```Go
 /**
diff --git a/problems/0027.移除元素.md b/problems/0027.移除元素.md
index 8da0fb89..f0f61d06 100644
--- a/problems/0027.移除元素.md
+++ b/problems/0027.移除元素.md
@@ -186,6 +186,20 @@ var removeElement = (nums, val) => {
 };
 ```
 
+Ruby:
+```ruby
+def remove_element(nums, val)
+    i = 0
+    nums.each_index do |j| 
+        if nums[j] != val
+            nums[i] = nums[j]
+            i+=1
+        end
+    end
+    i
+end
+```
+
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
diff --git a/problems/0039.组合总和.md b/problems/0039.组合总和.md
index 0eba785f..e1023ec9 100644
--- a/problems/0039.组合总和.md
+++ b/problems/0039.组合总和.md
@@ -237,34 +237,28 @@ public:
 
 Java：
 ```Java
+// 剪枝优化
 class Solution {
-    List<List<Integer>> lists = new ArrayList<>();
-    Deque<Integer> deque = new LinkedList<>();
-
-    public List<List<Integer>> combinationSum3(int k, int n) {
-        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
-        backTracking(arr, n, k, 0);
-        return lists;
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        List<List<Integer>> res = new ArrayList<>();
+        Arrays.sort(candidates); // 先进行排序
+        backtracking(res, new ArrayList<>(), candidates, target, 0, 0);
+        return res;
     }
 
-    public void backTracking(int[] arr, int n, int k, int startIndex) {
-        //如果 n 小于0，没必要继续本次递归，已经不符合要求了
-        if (n < 0) {
+    public void backtracking(List<List<Integer>> res, List<Integer> path, int[] candidates, int target, int sum, int idx) {
+        // 找到了数字和为 target 的组合
+        if (sum == target) {
+            res.add(new ArrayList<>(path));
             return;
         }
-        if (deque.size() == k) {
-            if (n == 0) {
-                lists.add(new ArrayList(deque));
-            }
-            return;
-        }
-        for (int i = startIndex; i < arr.length - (k - deque.size()) + 1; i++) {
-            deque.push(arr[i]);
-            //减去当前元素
-            n -= arr[i];
-            backTracking(arr, n, k, i + 1);
-            //恢复n
-            n += deque.pop();
+
+        for (int i = idx; i < candidates.length; i++) {
+            // 如果 sum + candidates[i] > target 就终止遍历
+            if (sum + candidates[i] > target) break;
+            path.add(candidates[i]);
+            backtracking(res, path, candidates, target, sum + candidates[i], i);
+            path.remove(path.size() - 1); // 回溯，移除路径 path 最后一个元素
         }
     }
 }
diff --git a/problems/0046.全排列.md b/problems/0046.全排列.md
index 0beb45cf..06367851 100644
--- a/problems/0046.全排列.md
+++ b/problems/0046.全排列.md
@@ -182,7 +182,45 @@ class Solution {
 ```
 
 Python：
+```python3
+class Solution:
+    def permute(self, nums: List[int]) -> List[List[int]]:
+        res = []  #存放符合条件结果的集合
+        path = []  #用来存放符合条件的结果
+        used = []  #用来存放已经用过的数字
+        def backtrack(nums,used):
+            if len(path) == len(nums):
+                return res.append(path[:])  #此时说明找到了一组
+            for i in range(0,len(nums)):
+                if nums[i] in used:
+                    continue  #used里已经收录的元素，直接跳过
+                path.append(nums[i])
+                used.append(nums[i])
+                backtrack(nums,used)
+                used.pop()
+                path.pop()
+        backtrack(nums,used)
+        return res
+```
 
+Python（优化，不用used数组）：
+```python3
+class Solution:
+    def permute(self, nums: List[int]) -> List[List[int]]:
+        res = []  #存放符合条件结果的集合
+        path = []  #用来存放符合条件的结果
+        def backtrack(nums):
+            if len(path) == len(nums):
+                return res.append(path[:])  #此时说明找到了一组
+            for i in range(0,len(nums)):
+                if nums[i] in path:  #path里已经收录的元素，直接跳过
+                    continue
+                path.append(nums[i])
+                backtrack(nums)  #递归
+                path.pop()  #回溯
+        backtrack(nums)
+        return res
+```
 
 Go：
 ```Go
diff --git a/problems/0055.跳跃游戏.md b/problems/0055.跳跃游戏.md
index b4b42a4a..8618515e 100644
--- a/problems/0055.跳跃游戏.md
+++ b/problems/0055.跳跃游戏.md
@@ -141,7 +141,20 @@ func canJUmp(nums []int) bool {
 }
 ```
 
-
+Javascript:
+```Javascript
+var canJump = function(nums) {
+    if(nums.length === 1) return true
+    let cover = 0
+    for(let i = 0; i <= cover; i++) {
+        cover = Math.max(cover, i + nums[i])
+        if(cover >= nums.length - 1) {
+            return true
+        }
+    }
+    return false
+};
+```
 
 
 -----------------------
diff --git a/problems/0078.子集.md b/problems/0078.子集.md
index 17c4fb5c..0b2f3c09 100644
--- a/problems/0078.子集.md
+++ b/problems/0078.子集.md
@@ -205,7 +205,20 @@ class Solution {
 ```
 
 Python：
-
+```python3
+class Solution:
+    def subsets(self, nums: List[int]) -> List[List[int]]:
+        res = []  
+        path = []  
+        def backtrack(nums,startIndex):
+            res.append(path[:])  #收集子集，要放在终止添加的上面，否则会漏掉自己
+            for i in range(startIndex,len(nums)):  #当startIndex已经大于数组的长度了，就终止了，for循环本来也结束了，所以不需要终止条件
+                path.append(nums[i])
+                backtrack(nums,i+1)  #递归
+                path.pop()  #回溯
+        backtrack(nums,0)
+        return res
+```
 
 Go：
 ```Go
diff --git a/problems/0090.子集II.md b/problems/0090.子集II.md
index 6b12a95b..71aef5c7 100644
--- a/problems/0090.子集II.md
+++ b/problems/0090.子集II.md
@@ -208,7 +208,23 @@ class Solution {
 ```
 
 Python：
-
+```python3
+class Solution:
+    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
+        res = []  #存放符合条件结果的集合
+        path = []  #用来存放符合条件结果
+        def backtrack(nums,startIndex):
+            res.append(path[:])
+            for i in range(startIndex,len(nums)):
+                if i > startIndex and nums[i] == nums[i - 1]:  #我们要对同一树层使用过的元素进行跳过
+                    continue
+                path.append(nums[i])
+                backtrack(nums,i+1)  #递归
+                path.pop()  #回溯
+        nums = sorted(nums)  #去重需要排序
+        backtrack(nums,0)
+        return res
+```
 
 Go：
 ```Go
diff --git a/problems/0096.不同的二叉搜索树.md b/problems/0096.不同的二叉搜索树.md
index cee0102f..a9631315 100644
--- a/problems/0096.不同的二叉搜索树.md
+++ b/problems/0096.不同的二叉搜索树.md
@@ -186,7 +186,16 @@ class Solution {
 ```
 
 Python：
-
+```python
+class Solution:
+    def numTrees(self, n: int) -> int:
+        dp = [0] * (n + 1)
+        dp[0], dp[1] = 1, 1
+        for i in range(2, n + 1):
+            for j in range(1, i + 1):
+                dp[i] += dp[j - 1] * dp[i - j]
+        return dp[-1]
+```
 
 Go：
 ```Go
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index ee93911e..00607082 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -836,6 +836,249 @@ func levelOrder(root *TreeNode) [][]int  {
 	return result
 }
 ```
+> 二叉树的层序遍历（GO语言完全版）
+
+```go
+/**
+102. 二叉树的层序遍历
+ */
+func levelOrder(root *TreeNode) [][]int {
+    res:=[][]int{}
+    if root==nil{//防止为空
+        return res
+    }
+    queue:=list.New()
+    queue.PushBack(root)
+    var tmpArr []int
+    for queue.Len()>0 {
+        length:=queue.Len()//保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        for i:=0;i<length;i++{
+            node:=queue.Remove(queue.Front()).(*TreeNode)//出队列
+            if node.Left!=nil{
+                queue.PushBack(node.Left)
+            }
+            if node.Right!=nil{
+                queue.PushBack(node.Right)
+            }
+            tmpArr=append(tmpArr,node.Val)//将值加入本层切片中
+        }
+        res=append(res,tmpArr)//放入结果集
+        tmpArr=[]int{}//清空层的数据
+    }
+    return res
+}
+
+/**
+107. 二叉树的层序遍历 II
+ */
+func levelOrderBottom(root *TreeNode) [][]int {
+    queue:=list.New()
+    res:=[][]int{}
+    if root==nil{
+        return res
+    }
+    queue.PushBack(root)
+    for queue.Len()>0{
+        length:=queue.Len()
+        tmp:=[]int{}
+        for i:=0;i<length;i++{
+            node:=queue.Remove(queue.Front()).(*TreeNode)
+            if node.Left!=nil{
+                queue.PushBack(node.Left)
+            }
+            if node.Right!=nil{
+                queue.PushBack(node.Right)
+            }
+            tmp=append(tmp,node.Val)
+        }
+        res=append(res,tmp)
+    }
+    //反转结果集
+    for i:=0;i<len(res)/2;i++{
+        res[i],res[len(res)-i-1]=res[len(res)-i-1],res[i]
+    }
+    return res
+}
+
+/**
+199. 二叉树的右视图
+ */
+func rightSideView(root *TreeNode) []int {
+    queue:=list.New()
+    res:=[][]int{}
+    var finaRes []int
+    if root==nil{
+        return finaRes
+    }
+    queue.PushBack(root)
+    for queue.Len()>0{
+        length:=queue.Len()
+        tmp:=[]int{}
+        for i:=0;i<length;i++{
+            node:=queue.Remove(queue.Front()).(*TreeNode)
+            if node.Left!=nil{
+                queue.PushBack(node.Left)
+            }
+            if node.Right!=nil{
+                queue.PushBack(node.Right)
+            }
+            tmp=append(tmp,node.Val)
+        }
+        res=append(res,tmp)
+    }
+    //取每一层的最后一个元素
+    for i:=0;i<len(res);i++{
+        finaRes=append(finaRes,res[i][len(res[i])-1])
+    }
+    return finaRes
+}
+
+/**
+637. 二叉树的层平均值
+ */
+func averageOfLevels(root *TreeNode) []float64 {
+    res:=[][]int{}
+    var finRes []float64
+    if root==nil{//防止为空
+        return finRes
+    }
+    queue:=list.New()
+    queue.PushBack(root)
+    var tmpArr []int
+    for queue.Len()>0 {
+        length:=queue.Len()//保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        for i:=0;i<length;i++{
+            node:=queue.Remove(queue.Front()).(*TreeNode)//出队列
+            if node.Left!=nil{
+                queue.PushBack(node.Left)
+            }
+            if node.Right!=nil{
+                queue.PushBack(node.Right)
+            }
+            tmpArr=append(tmpArr,node.Val)//将值加入本层切片中
+        }
+        res=append(res,tmpArr)//放入结果集
+        tmpArr=[]int{}//清空层的数据
+    }
+    //计算每层的平均值
+    length:=len(res)
+    for i:=0;i<length;i++{
+        var sum int
+        for j:=0;j<len(res[i]);j++{
+            sum+=res[i][j]
+        }
+        tmp:=float64(sum)/float64(len(res[i]))
+        finRes=append(finRes,tmp)//将平均值放入结果集合
+    }
+    return finRes
+}
+
+/**
+429. N 叉树的层序遍历
+ */
+
+func levelOrder(root *Node) [][]int {
+    queue:=list.New()
+    res:=[][]int{}//结果集
+    if root==nil{
+        return res
+    }
+    queue.PushBack(root)
+    for queue.Len()>0{
+        length:=queue.Len()//记录当前层的数量
+        var tmp []int
+        for T:=0;T<length;T++{//该层的每个元素：一添加到该层的结果集中；二找到该元素的下层元素加入到队列中，方便下次使用
+            myNode:=queue.Remove(queue.Front()).(*Node)
+            tmp=append(tmp,myNode.Val)
+            for i:=0;i<len(myNode.Children);i++{
+                queue.PushBack(myNode.Children[i])
+            }
+        }
+        res=append(res,tmp)
+    }
+    return res
+}
+
+/**
+515. 在每个树行中找最大值
+ */
+func largestValues(root *TreeNode) []int {
+    res:=[][]int{}
+    var finRes []int
+    if root==nil{//防止为空
+        return finRes
+    }
+    queue:=list.New()
+    queue.PushBack(root)
+    var tmpArr []int
+    //层次遍历
+    for queue.Len()>0 {
+        length:=queue.Len()//保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        for i:=0;i<length;i++{
+            node:=queue.Remove(queue.Front()).(*TreeNode)//出队列
+            if node.Left!=nil{
+                queue.PushBack(node.Left)
+            }
+            if node.Right!=nil{
+                queue.PushBack(node.Right)
+            }
+            tmpArr=append(tmpArr,node.Val)//将值加入本层切片中
+        }
+        res=append(res,tmpArr)//放入结果集
+        tmpArr=[]int{}//清空层的数据
+    }
+    //找到每层的最大值
+    for i:=0;i<len(res);i++{
+        finRes=append(finRes,max(res[i]...))
+    }
+    return finRes
+}
+func max(vals...int) int {
+    max:=int(math.Inf(-1))//负无穷
+    for _, val := range vals {
+        if val > max {
+            max = val
+        }
+    }
+    return max
+}
+/**
+116. 填充每个节点的下一个右侧节点指针
+117. 填充每个节点的下一个右侧节点指针 II
+ */
+
+func connect(root *Node) *Node {
+   res:=[][]*Node{}
+    if root==nil{//防止为空
+        return root
+    }
+    queue:=list.New()
+    queue.PushBack(root)
+    var tmpArr []*Node
+    for queue.Len()>0 {
+        length:=queue.Len()//保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        for i:=0;i<length;i++{
+            node:=queue.Remove(queue.Front()).(*Node)//出队列
+            if node.Left!=nil{
+                queue.PushBack(node.Left)
+            }
+            if node.Right!=nil{
+                queue.PushBack(node.Right)
+            }
+            tmpArr=append(tmpArr,node)//将值加入本层切片中
+        }
+        res=append(res,tmpArr)//放入结果集
+        tmpArr=[]*Node{}//清空层的数据
+    }
+    //遍历每层元素,指定next
+    for i:=0;i<len(res);i++{
+        for j:=0;j<len(res[i])-1;j++{
+            res[i][j].Next=res[i][j+1]
+        }
+    }
+    return root
+}
+```
 Javascript:
 ```javascript
 var levelOrder = function (root) {
diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index b4a3f38b..4ccd8912 100644
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@@ -524,6 +524,62 @@ let pathSum = function (root, targetSum) {
 };
 ```
 
+0112 路径总和
+```javascript
+var hasPathSum = function(root, targetSum) {
+    //递归方法
+    // 1. 确定函数参数
+    const traversal = function(node,count){
+        // 2. 确定终止条件
+        if(node.left===null&&node.right===null&&count===0){
+            return true;
+        }
+        if(node.left===null&&node.right===null){
+            return false;
+        }
+        //3. 单层递归逻辑
+        if(node.left){
+            if(traversal(node.left,count-node.left.val)){
+                return true;
+            }
+        }
+        if(node.right){
+            if(traversal(node.right,count-node.right.val)){
+                return true;
+            }
+        }
+        return false;
+    }
+    if(root===null){
+        return false;
+    }
+    return traversal(root,targetSum-root.val);
+};
+```
+113 路径总和
+```javascript
+var pathSum = function(root, targetSum) {
+    //递归方法
+    let resPath = [],curPath = [];
+    // 1. 确定递归函数参数
+    const travelTree = function(node,count){
+        curPath.push(node.val);
+        count-=node.val;
+        if(node.left===null&&node.right===null&&count===0){
+            resPath.push([...curPath]);
+        }
+        node.left&&travelTree(node.left,count);
+        node.right&&travelTree(node.right,count);
+        let cur = curPath.pop();
+        count-=cur;
+    }
+    if(root===null){
+        return resPath;
+    }
+    travelTree(root,targetSum);
+    return resPath;
+};
+```
 
 
 
diff --git a/problems/0142.环形链表II.md b/problems/0142.环形链表II.md
index 15c2d1f9..9deb1e0c 100644
--- a/problems/0142.环形链表II.md
+++ b/problems/0142.环形链表II.md
@@ -234,25 +234,19 @@ class Solution:
 ```
 
 Go：
-```func detectCycle(head *ListNode) *ListNode {
-    if head ==nil{
-        return head 
-    }
-    slow:=head
-    fast:=head.Next
-
-    for fast!=nil&&fast.Next!=nil{
-        if fast==slow{
-            slow=head
-            fast=fast.Next
-            for fast!=slow {
-                fast=fast.Next
-                slow=slow.Next
+```go
+func detectCycle(head *ListNode) *ListNode {
+    slow, fast := head, head
+    for fast != nil && fast.Next != nil {
+        slow = slow.Next
+        fast = fast.Next.Next
+        if slow == fast {
+            for slow != head {
+                slow = slow.Next
+                head = head.Next
             }
-            return slow
+            return head
         }
-        fast=fast.Next.Next
-        slow=slow.Next
     }
     return nil
 }
diff --git a/problems/0150.逆波兰表达式求值.md b/problems/0150.逆波兰表达式求值.md
index e38bc1a3..c8b0da08 100644
--- a/problems/0150.逆波兰表达式求值.md
+++ b/problems/0150.逆波兰表达式求值.md
@@ -224,6 +224,22 @@ var evalRPN = function(tokens) {
 };
 ```
 
+python3
+
+```python
+def evalRPN(tokens) -> int:
+    stack = list()
+    for i in range(len(tokens)):
+        if tokens[i] not in ["+", "-", "*", "/"]:
+            stack.append(tokens[i])
+        else:
+            tmp1 = stack.pop()
+            tmp2 = stack.pop()
+            res = eval(tmp2+tokens[i]+tmp1)
+            stack.append(str(int(res)))
+    return stack[-1]
+```
+
 
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
diff --git a/problems/0203.移除链表元素.md b/problems/0203.移除链表元素.md
index dce5d265..cac9f233 100644
--- a/problems/0203.移除链表元素.md
+++ b/problems/0203.移除链表元素.md
@@ -208,7 +208,23 @@ public ListNode removeElements(ListNode head, int val) {
 ```
 
 Python：
-
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def removeElements(self, head: ListNode, val: int) -> ListNode:
+        dummy_head = ListNode(next=head) #添加一个虚拟节点
+        cur = dummy_head
+        while(cur.next!=None):
+            if(cur.next.val == val):
+                cur.next = cur.next.next #删除cur.next节点
+            else:
+                cur = cur.next
+        return dummy_head.next
+```
 
 Go：
 
diff --git a/problems/0206.翻转链表.md b/problems/0206.翻转链表.md
index 52ef6484..7c002382 100644
--- a/problems/0206.翻转链表.md
+++ b/problems/0206.翻转链表.md
@@ -143,7 +143,25 @@ class Solution {
 ```
 
 Python：
-
+```python
+#双指针
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def reverseList(self, head: ListNode) -> ListNode:
+        cur = head   
+        pre = None
+        while(cur!=None):
+            temp = cur.next # 保存一下 cur的下一个节点，因为接下来要改变cur->next
+            cur.next = pre #反转
+            #更新pre、cur指针
+            pre = cur
+            cur = temp
+        return pre
+```
 
 Go：
 
diff --git a/problems/0232.用栈实现队列.md b/problems/0232.用栈实现队列.md
index 10314a08..c2af71f7 100644
--- a/problems/0232.用栈实现队列.md
+++ b/problems/0232.用栈实现队列.md
@@ -282,6 +282,50 @@ class MyQueue {
 
 
 Python：
+```python
+# 使用两个栈实现先进先出的队列
+class MyQueue:
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.stack1 = list()
+        self.stack2 = list()
+
+    def push(self, x: int) -> None:
+        """
+        Push element x to the back of queue.
+        """
+        # self.stack1用于接受元素
+        self.stack1.append(x)
+
+    def pop(self) -> int:
+        """
+        Removes the element from in front of queue and returns that element.
+        """
+        # self.stack2用于弹出元素，如果self.stack2为[],则将self.stack1中元素全部弹出给self.stack2
+        if self.stack2 == []:
+            while self.stack1:
+                tmp = self.stack1.pop()
+                self.stack2.append(tmp)
+        return self.stack2.pop()
+
+    def peek(self) -> int:
+        """
+        Get the front element.
+        """
+        if self.stack2 == []:
+            while self.stack1:
+                tmp = self.stack1.pop()
+                self.stack2.append(tmp)
+        return self.stack2[-1]
+
+    def empty(self) -> bool:
+        """
+        Returns whether the queue is empty.
+        """
+        return self.stack1 == [] and self.stack2 == []
+```
 
 
 Go：
diff --git a/problems/0343.整数拆分.md b/problems/0343.整数拆分.md
index c9423a1a..fefaa293 100644
--- a/problems/0343.整数拆分.md
+++ b/problems/0343.整数拆分.md
@@ -51,10 +51,6 @@ dp[i]的定义讲贯彻整个解题过程，下面哪一步想不懂了，就想
 
 **那有同学问了，j怎么就不拆分呢？**
 
-j是从1开始遍历，拆分j的情况，在遍历j的过程中其实都计算过了。
-
-**那有同学问了，j怎么就不拆分呢？**
-
 j是从1开始遍历，拆分j的情况，在遍历j的过程中其实都计算过了。那么从1遍历j，比较(i - j) * j和dp[i - j] * j 取最大的。递推公式：dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
 
 也可以这么理解，j * (i - j) 是单纯的把整数拆分为两个数相乘，而j * dp[i - j]是拆分成两个以及两个以上的个数相乘。
@@ -213,8 +209,19 @@ class Solution {
 ```
 
 Python：
-
-
+```python
+class Solution:
+    def integerBreak(self, n: int) -> int:
+        dp = [0] * (n + 1)
+        dp[2] = 1
+        for i in range(3, n + 1):
+            # 假设对正整数 i 拆分出的第一个正整数是 j（1 <= j < i），则有以下两种方案：
+            # 1) 将 i 拆分成 j 和 i−j 的和，且 i−j 不再拆分成多个正整数，此时的乘积是 j * (i-j)
+            # 2) 将 i 拆分成 j 和 i−j 的和，且 i−j 继续拆分成多个正整数，此时的乘积是 j * dp[i-j]
+            for j in range(1, i):
+                dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))
+        return dp[n]
+```
 Go：
 
 
diff --git a/problems/0349.两个数组的交集.md b/problems/0349.两个数组的交集.md
index fe019a0a..090480a4 100644
--- a/problems/0349.两个数组的交集.md
+++ b/problems/0349.两个数组的交集.md
@@ -132,6 +132,23 @@ class Solution:
 
 
 Go：
+```go
+func intersection(nums1 []int, nums2 []int) []int {
+    m := make(map[int]int)
+    for _, v := range nums1 {
+        m[v] = 1
+    }
+    var res []int
+    // 利用count>0，实现重复值只拿一次放入返回结果中
+    for _, v := range nums2 {
+        if count, ok := m[v]; ok && count > 0 {
+            res = append(res, v)
+            m[v]--
+        }
+    }
+    return res
+}
+```
 
 javaScript:
 
diff --git a/problems/0404.左叶子之和.md b/problems/0404.左叶子之和.md
index 30d702b4..e5daa9db 100644
--- a/problems/0404.左叶子之和.md
+++ b/problems/0404.左叶子之和.md
@@ -226,7 +226,51 @@ class Solution:
 ```
 Go：
 
-
+JavaScript:
+递归版本
+```javascript
+var sumOfLeftLeaves = function(root) {
+    //采用后序遍历 递归遍历
+    // 1. 确定递归函数参数
+    const nodesSum = function(node){
+        // 2. 确定终止条件
+        if(node===null){
+            return 0;
+        }
+        let leftValue = sumOfLeftLeaves(node.left);
+        let rightValue = sumOfLeftLeaves(node.right);
+        // 3. 单层递归逻辑
+        let midValue = 0;
+        if(node.left&&node.left.left===null&&node.left.right===null){
+            midValue = node.left.val;
+        }
+        let sum = midValue + leftValue + rightValue;
+        return sum;
+    }
+    return nodesSum(root);
+};
+```
+迭代版本
+```javascript
+var sumOfLeftLeaves = function(root) {
+   //采用层序遍历
+   if(root===null){
+       return null;
+   }
+   let queue = [];
+   let sum = 0;
+   queue.push(root);
+   while(queue.length){
+     let node = queue.shift();
+     if(node.left!==null&&node.left.left===null&&node.left.right===null){
+         sum+=node.left.val;
+     }
+     node.left&&queue.push(node.left);
+     node.right&&queue.push(node.right);
+   }
+   return sum;
+};
+```
 
 
 
diff --git a/problems/0416.分割等和子集.md b/problems/0416.分割等和子集.md
index e69eb1a4..55d200e2 100644
--- a/problems/0416.分割等和子集.md
+++ b/problems/0416.分割等和子集.md
@@ -222,8 +222,18 @@ class Solution {
 ```
 
 Python：
-
-
+```python
+class Solution:
+    def canPartition(self, nums: List[int]) -> bool:
+        taraget = sum(nums)
+        if taraget % 2 == 1: return False
+        taraget //= 2
+        dp = [0] * 10001
+        for i in range(len(nums)):
+            for j in range(taraget, nums[i] - 1, -1):
+                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
+        return taraget == dp[taraget]
+```
 Go：
 
 
diff --git a/problems/0491.递增子序列.md b/problems/0491.递增子序列.md
index 691f7aef..5538a2c9 100644
--- a/problems/0491.递增子序列.md
+++ b/problems/0491.递增子序列.md
@@ -229,7 +229,28 @@ class Solution {
 
 
 Python：
-
+```python3
+class Solution:
+    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
+        res = []
+        path = []
+        def backtrack(nums,startIndex):
+            repeat = []  #这里使用数组来进行去重操作
+            if len(path) >=2:
+                res.append(path[:])  #注意这里不要加return，要取树上的节点
+            for i in range(startIndex,len(nums)):
+                if nums[i] in repeat:
+                    continue
+                if len(path) >= 1:
+                    if nums[i] < path[-1]:
+                        continue
+                repeat.append(nums[i])  #记录这个元素在本层用过了，本层后面不能再用了
+                path.append(nums[i])
+                backtrack(nums,i+1)
+                path.pop()
+        backtrack(nums,0)
+        return res
+```
 
 Go：
 
diff --git a/problems/0513.找树左下角的值.md b/problems/0513.找树左下角的值.md
index 5c9613e5..97464e3d 100644
--- a/problems/0513.找树左下角的值.md
+++ b/problems/0513.找树左下角的值.md
@@ -298,6 +298,53 @@ class Solution:
 ```
 Go：
 
+JavaScript:
+1. 递归版本
+```javascript
+var findBottomLeftValue = function(root) {
+    //首先考虑递归遍历 前序遍历 找到最大深度的叶子节点即可
+    let maxPath = 0,resNode = null;
+    // 1. 确定递归函数的函数参数
+    const dfsTree = function(node,curPath){
+    // 2. 确定递归函数终止条件
+        if(node.left===null&&node.right===null){
+            if(curPath>maxPath){
+            maxPath = curPath;
+            resNode = node.val;
+            }
+            // return ;
+        }
+        node.left&&dfsTree(node.left,curPath+1);
+        node.right&&dfsTree(node.right,curPath+1);
+    }
+    dfsTree(root,1);
+    return resNode;
+};
+```
+2. 层序遍历
+```javascript
+var findBottomLeftValue = function(root) {
+    //考虑层序遍历 记录最后一行的第一个节点
+    let queue = [];
+    if(root===null){
+        return null;
+    }
+    queue.push(root);
+    let resNode;
+    while(queue.length){
+        let length =  queue.length;
+        for(let i=0; i<length; i++){
+            let node = queue.shift();
+            if(i===0){
+                resNode = node.val;
+            }
+            node.left&&queue.push(node.left);
+            node.right&&queue.push(node.right);
+        }
+    }
+    return resNode;
+};
+```
 
 
 
diff --git a/problems/0541.反转字符串II.md b/problems/0541.反转字符串II.md
index db53caf7..6c8f3e94 100644
--- a/problems/0541.反转字符串II.md
+++ b/problems/0541.反转字符串II.md
@@ -106,27 +106,24 @@ Java：
 class Solution {
     public String reverseStr(String s, int k) {
         StringBuffer res = new StringBuffer();
-
-        for (int i = 0; i < s.length(); i += (2 * k)) {
+        int length = s.length();
+        int start = 0;
+        while (start < length) {
+            // 找到k处和2k处
             StringBuffer temp = new StringBuffer();
-            // 剩余字符大于 k 个，每隔 2k 个字符的前 k 个字符进行反转
-            if (i + k <= s.length()) {
-                // 反转前 k 个字符
-                temp.append(s.substring(i, i + k));
-                res.append(temp.reverse());
+            // 与length进行判断，如果大于length了，那就将其置为length
+            int firstK = (start + k > length) ? length : start + k;
+            int secondK = (start + (2 * k) > length) ? length : start + (2 * k);
 
-                // 反转完前 k 个字符之后，如果紧接着还有 k 个字符，则直接加入这 k 个字符
-                if (i + 2 * k <= s.length()) {
-                    res.append(s.substring(i + k, i + 2 * k));
-                // 不足 k 个字符，则直接加入剩下所有字符
-                } else {
-                    res.append(s.substring(i + k, s.length()));
-                }
-                continue;
-            }
-            // 剩余字符少于 k 个，则将剩余字符全部反转。
-            temp.append(s.substring(i, s.length()));
+            //无论start所处位置，至少会反转一次
+            temp.append(s.substring(start, firstK));
             res.append(temp.reverse());
+
+            // 如果firstK到secondK之间有元素，这些元素直接放入res里即可。
+            if (firstK < secondK) { //此时剩余长度一定大于k。
+                res.append(s.substring(firstK, secondK));
+            }
+            start += (2 * k);
         }
         return res.toString();
     }
diff --git a/problems/0977.有序数组的平方.md b/problems/0977.有序数组的平方.md
index 167a258c..b5d392e6 100644
--- a/problems/0977.有序数组的平方.md
+++ b/problems/0977.有序数组的平方.md
@@ -100,10 +100,66 @@ public:
 Java：
 
 Python：
-
+```Python
+class Solution:
+    def sortedSquares(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        i,j,k = 0,n - 1,n - 1
+        ans = [-1] * n
+        while i <= j:
+            lm = nums[i] ** 2
+            rm = nums[j] ** 2
+            if lm > rm:
+                ans[k] = lm
+                i += 1
+            else:
+                ans[k] = rm
+                j -= 1
+            k -= 1
+        return ans
+```
 
 Go：
-
+```Go
+func sortedSquares(nums []int) []int {
+	n := len(nums)
+	i, j, k := 0, n-1, n-1
+	ans := make([]int, n)
+	for i <= j {
+		lm, rm := nums[i]*nums[i], nums[j]*nums[j]
+		if lm > rm {
+			ans[k] = lm
+			i++
+		} else {
+			ans[k] = rm
+			j--
+		}
+		k--
+	}
+	return ans
+}
+```
+Rust
+```
+impl Solution {
+    pub fn sorted_squares(nums: Vec<i32>) -> Vec<i32> {
+        let n = nums.len();
+        let (mut i,mut j,mut k) = (0,n - 1,n- 1);
+        let mut ans = vec![0;n];
+        while i <= j{
+            if nums[i] * nums[i] < nums[j] * nums[j] {
+                ans[k] = nums[j] * nums[j];
+                j -= 1;
+            }else{
+                ans[k] = nums[i] * nums[i];
+                i += 1;
+            }
+            k -= 1;
+        }
+        ans
+    }
+}
+```
 
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
diff --git a/problems/面试题02.07.链表相交.md b/problems/面试题02.07.链表相交.md
index 9e97264c..78f34e71 100644
--- a/problems/面试题02.07.链表相交.md
+++ b/problems/面试题02.07.链表相交.md
@@ -151,10 +151,83 @@ public class Solution {
 ```
 
 Python：
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
 
+class Solution:
+    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
+        lengthA,lengthB = 0,0
+        curA,curB = headA,headB
+        while(curA!=None): #求链表A的长度
+            curA = curA.next
+            lengthA +=1
+        
+        while(curB!=None): #求链表B的长度
+            curB = curB.next
+            lengthB +=1
+        
+        curA, curB = headA, headB
+
+        if lengthB>lengthA: #让curA为最长链表的头，lenA为其长度
+            lengthA, lengthB = lengthB, lengthA
+            curA, curB = curB, curA
+
+        gap = lengthA - lengthB #求长度差
+        while(gap!=0): 
+            curA = curA.next #让curA和curB在同一起点上
+            gap -= 1
+        
+        while(curA!=None):
+            if curA == curB:
+                return curA
+            else:
+                curA = curA.next
+                curB = curB.next
+        return None
+```
 
 Go：
 
+```go
+func getIntersectionNode(headA, headB *ListNode) *ListNode {
+    curA := headA
+    curB := headB
+    lenA, lenB := 0, 0
+    // 求A，B的长度
+    for curA != nil {
+        curA = curA.Next
+        lenA++
+    }
+    for curB != nil {
+        curB = curB.Next
+        lenB++
+    }
+    var step int
+    var fast, slow *ListNode
+    // 请求长度差，并且让更长的链表先走相差的长度
+    if lenA > lenB {
+        step = lenA - lenB
+        fast, slow = headA, headB
+    } else {
+        step = lenB - lenA
+        fast, slow = headB, headA
+    }
+    for i:=0; i < step; i++ {
+        fast = fast.Next
+    }
+    // 遍历两个链表遇到相同则跳出遍历
+    for fast != slow {
+        fast = fast.Next
+        slow = slow.Next
+    }
+    return fast
+}
+```
+
 javaScript: 
 
 ```js