diff --git a/problems/0106.从中序与后序遍历序列构造二叉树.md b/problems/0106.从中序与后序遍历序列构造二叉树.md
index ba2d46a1..600a38e0 100644
--- a/problems/0106.从中序与后序遍历序列构造二叉树.md
+++ b/problems/0106.从中序与后序遍历序列构造二叉树.md
@@ -693,6 +693,70 @@ class Solution:
             return root
 ```
 Go：
+> 106 从中序与后序遍历序列构造二叉树
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func buildTree(inorder []int, postorder []int) *TreeNode {
+    if len(inorder)<1||len(postorder)<1{return nil}
+    //先找到根节点（后续遍历的最后一个就是根节点）
+    nodeValue:=postorder[len(postorder)-1]
+    //从中序遍历中找到一分为二的点，左边为左子树，右边为右子树
+    left:=findRootIndex(inorder,nodeValue)
+    //构造root
+    root:=&TreeNode{Val: nodeValue,
+                Left: buildTree(inorder[:left],postorder[:left]),//将后续遍历一分为二，左边为左子树，右边为右子树
+                Right: buildTree(inorder[left+1:],postorder[left:len(postorder)-1])}
+    return root
+}
+func findRootIndex(inorder []int,target int) (index int){
+    for i:=0;i<len(inorder);i++{
+        if target==inorder[i]{
+            return i
+        }
+    }
+    return -1
+}
+```
+
+> 105 从前序与中序遍历序列构造二叉树
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func buildTree(preorder []int, inorder []int) *TreeNode {
+    if len(preorder)<1||len(inorder)<1{return nil}
+    left:=findRootIndex(preorder[0],inorder)
+    root:=&TreeNode{
+        Val: preorder[0],
+        Left: buildTree(preorder[1:left+1],inorder[:left]),
+        Right: buildTree(preorder[left+1:],inorder[left+1:])}
+    return root
+}
+func findRootIndex(target int,inorder []int) int{
+    for i:=0;i<len(inorder);i++{
+        if target==inorder[i]{
+            return i
+        }
+    }
+    return -1
+}
+```
+
+
 
 
 JavaScript
diff --git a/problems/0115.不同的子序列.md b/problems/0115.不同的子序列.md
index e54389aa..d3bc6d97 100644
--- a/problems/0115.不同的子序列.md
+++ b/problems/0115.不同的子序列.md
@@ -145,7 +145,28 @@ public:
 
 
 Java：
-
+```java
+class Solution {
+    public int numDistinct(String s, String t) {
+        int[][] dp = new int[s.length() + 1][t.length() + 1];
+        for (int i = 0; i < s.length() + 1; i++) {
+            dp[i][0] = 1;
+        }
+        
+        for (int i = 1; i < s.length() + 1; i++) {
+            for (int j = 1; j < t.length() + 1; j++) {
+                if (s.charAt(i - 1) == t.charAt(j - 1)) {
+                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
+                }else{
+                    dp[i][j] = dp[i - 1][j];
+                }
+            }
+        }
+        
+        return dp[s.length()][t.length()];
+    }
+}
+```
 
 Python：
 ```python
diff --git a/problems/0242.有效的字母异位词.md b/problems/0242.有效的字母异位词.md
index ba942f70..93bba44c 100644
--- a/problems/0242.有效的字母异位词.md
+++ b/problems/0242.有效的字母异位词.md
@@ -130,7 +130,27 @@ class Solution:
         return True
 ```
 
+Python写法二（没有使用数组作为哈希表，只是介绍defaultdict这样一种解题思路）：
+
+```python
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        from collections import defaultdict
+        
+        s_dict = defaultdict(int)
+        t_dict = defaultdict(int)
+
+        for x in s:
+            s_dict[x] += 1
+        
+        for x in t:
+            t_dict[x] += 1
+
+        return s_dict == t_dict
+```
+
 Go：
+
 ```go
 func isAnagram(s string, t string) bool {
     if len(s)!=len(t){
diff --git a/problems/0530.二叉搜索树的最小绝对差.md b/problems/0530.二叉搜索树的最小绝对差.md
index 03c48d9c..0bbc4908 100644
--- a/problems/0530.二叉搜索树的最小绝对差.md
+++ b/problems/0530.二叉搜索树的最小绝对差.md
@@ -224,8 +224,37 @@ class Solution:
         return r
 ```
 Go：
+> 中序遍历，然后计算最小差值
 
-
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func getMinimumDifference(root *TreeNode) int {
+    var res []int
+    findMIn(root,&res)
+    min:=1000000//一个比较大的值
+    for i:=1;i<len(res);i++{
+        tempValue:=res[i]-res[i-1]
+        if tempValue<min{
+            min=tempValue
+        }
+    }
+    return min
+}
+//中序遍历
+func findMIn(root *TreeNode,res *[]int){
+    if root==nil{return}
+    findMIn(root.Left,res)
+    *res=append(*res,root.Val)
+    findMIn(root.Right,res)
+}
+```
 
 
 -----------------------
diff --git a/problems/0583.两个字符串的删除操作.md b/problems/0583.两个字符串的删除操作.md
index 0b32d129..ee1fbc5f 100644
--- a/problems/0583.两个字符串的删除操作.md
+++ b/problems/0583.两个字符串的删除操作.md
@@ -104,6 +104,28 @@ public:
 
 
 Java：
+```java
+class Solution {
+    public int minDistance(String word1, String word2) {
+        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
+        for (int i = 0; i < word1.length() + 1; i++) dp[i][0] = i;
+        for (int j = 0; j < word2.length() + 1; j++) dp[0][j] = j;
+        
+        for (int i = 1; i < word1.length() + 1; i++) {
+            for (int j = 1; j < word2.length() + 1; j++) {
+                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
+                    dp[i][j] = dp[i - 1][j - 1];
+                }else{
+                    dp[i][j] = Math.min(dp[i - 1][j - 1] + 2,
+                                        Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1));
+                }
+            }
+        }
+        
+        return dp[word1.length()][word2.length()];
+    }
+}
+```
 
 
 Python：
diff --git a/problems/0617.合并二叉树.md b/problems/0617.合并二叉树.md
index d65275f0..be6bb425 100644
--- a/problems/0617.合并二叉树.md
+++ b/problems/0617.合并二叉树.md
@@ -332,6 +332,43 @@ class Solution:
 
 Go：
 
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+ //前序遍历（递归遍历，跟105 106差不多的思路）
+func mergeTrees(t1 *TreeNode, t2 *TreeNode) *TreeNode {
+    var value int 
+    var nullNode *TreeNode//空node，便于遍历
+    nullNode=&TreeNode{
+        Val:0,
+        Left:nil,
+        Right:nil}
+    switch {
+        case t1==nil&&t2==nil: return nil//终止条件
+        default : //如果其中一个节点为空，则将该节点置为nullNode，方便下次遍历
+        if t1==nil{
+            value=t2.Val
+            t1=nullNode
+        }else if t2==nil{
+            value=t1.Val
+            t2=nullNode
+        }else {
+            value=t1.Val+t2.Val
+        }
+    }
+    root:=&TreeNode{//构造新的二叉树
+        Val: value,
+        Left: mergeTrees(t1.Left,t2.Left),
+        Right: mergeTrees(t1.Right,t2.Right)}
+    return root
+}
+```
 
 
 
diff --git a/problems/0654.最大二叉树.md b/problems/0654.最大二叉树.md
index ea8c15cd..f0d3e594 100644
--- a/problems/0654.最大二叉树.md
+++ b/problems/0654.最大二叉树.md
@@ -278,6 +278,39 @@ class Solution:
 
 Go：
 
+> 654. 最大二叉树
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func constructMaximumBinaryTree(nums []int) *TreeNode {
+    if len(nums)<1{return nil}
+    //首选找到最大值
+    index:=findMax(nums)
+    //其次构造二叉树
+    root:=&TreeNode{
+        Val: nums[index],
+        Left:constructMaximumBinaryTree(nums[:index]),//左半边
+        Right:constructMaximumBinaryTree(nums[index+1:]),//右半边
+        }
+    return root
+}
+func findMax(nums []int) (index int){
+    for i:=0;i<len(nums);i++{
+        if nums[i]>nums[index]{
+            index=i
+        }
+    }
+    return 
+}
+```
+
 
 
 
diff --git a/problems/0700.二叉搜索树中的搜索.md b/problems/0700.二叉搜索树中的搜索.md
index 25a06617..16b21f26 100644
--- a/problems/0700.二叉搜索树中的搜索.md
+++ b/problems/0700.二叉搜索树中的搜索.md
@@ -241,6 +241,56 @@ class Solution:
 
 Go：
 
+> 递归法
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+ //递归法
+func searchBST(root *TreeNode, val int) *TreeNode {
+    if root==nil||root.Val==val{
+        return root
+    }
+    if root.Val>val{
+        return searchBST(root.Left,val)
+    }
+    return searchBST(root.Right,val)
+}
+```
+
+> 迭代法
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+ //迭代法
+func searchBST(root *TreeNode, val int) *TreeNode {
+    for root!=nil{
+        if root.Val>val{
+            root=root.Left
+        }else if root.Val<val{
+            root=root.Right
+        }else{
+            break
+        }
+    }
+    return root
+}
+```
+
+
 
 
 
diff --git a/problems/0707.设计链表.md b/problems/0707.设计链表.md
index 2fa1af29..7d5fde1f 100644
--- a/problems/0707.设计链表.md
+++ b/problems/0707.设计链表.md
@@ -158,6 +158,7 @@ private:
 
 Java：
 ```Java
+//单链表
 class ListNode {
 int val;
 ListNode next;
@@ -236,6 +237,106 @@ class MyLinkedList {
         pred.next = pred.next.next;
     }
 }
+
+//双链表
+class MyLinkedList {
+    class ListNode {
+        int val;
+        ListNode next,prev;
+        ListNode(int x) {val = x;}
+    }
+
+    int size;
+    ListNode head,tail;//Sentinel node
+
+    /** Initialize your data structure here. */
+    public MyLinkedList() {
+        size = 0;
+        head = new ListNode(0);
+        tail = new ListNode(0);
+        head.next = tail;
+        tail.prev = head;
+    }
+    
+    /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
+    public int get(int index) {
+        if(index < 0 || index >= size){return -1;}
+        ListNode cur = head;
+
+        // 通过判断 index < (size - 1) / 2 来决定是从头结点还是尾节点遍历，提高效率
+        if(index < (size - 1) / 2){
+            for(int i = 0; i <= index; i++){
+                cur = cur.next;
+            }            
+        }else{
+            cur = tail;
+            for(int i = 0; i <= size - index - 1; i++){
+                cur = cur.prev;
+            }
+        }
+        return cur.val;
+    }
+    
+    /** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
+    public void addAtHead(int val) {
+        ListNode cur = head;
+        ListNode newNode = new ListNode(val);
+        newNode.next = cur.next;
+        cur.next.prev = newNode;
+        cur.next = newNode;
+        newNode.prev = cur;
+        size++;
+    }
+    
+    /** Append a node of value val to the last element of the linked list. */
+    public void addAtTail(int val) {
+        ListNode cur = tail;
+        ListNode newNode = new ListNode(val);
+        newNode.next = tail;
+        newNode.prev = cur.prev;
+        cur.prev.next = newNode;
+        cur.prev = newNode;
+        size++;
+    }
+    
+    /** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
+    public void addAtIndex(int index, int val) {
+        if(index > size){return;}
+        if(index < 0){index = 0;}
+        ListNode cur = head;
+        for(int i = 0; i < index; i++){
+            cur = cur.next;
+        }
+        ListNode newNode = new ListNode(val);
+        newNode.next = cur.next;
+        cur.next.prev = newNode;
+        newNode.prev = cur;
+        cur.next = newNode;
+        size++;
+    }
+    
+    /** Delete the index-th node in the linked list, if the index is valid. */
+    public void deleteAtIndex(int index) {
+        if(index >= size || index < 0){return;}
+        ListNode cur = head;
+        for(int i = 0; i < index; i++){
+            cur = cur.next;
+        }
+        cur.next.next.prev = cur;
+        cur.next = cur.next.next;
+        size--;
+    }
+}
+
+/**
+ * Your MyLinkedList object will be instantiated and called as such:
+ * MyLinkedList obj = new MyLinkedList();
+ * int param_1 = obj.get(index);
+ * obj.addAtHead(val);
+ * obj.addAtTail(val);
+ * obj.addAtIndex(index,val);
+ * obj.deleteAtIndex(index);
+ */
 ```
 
 Python：
diff --git a/problems/0739.每日温度.md b/problems/0739.每日温度.md
index 1f91e42a..eeea6ead 100644
--- a/problems/0739.每日温度.md
+++ b/problems/0739.每日温度.md
@@ -214,6 +214,52 @@ Python：
 
 Go：
 
+> 暴力法
+
+```go
+func dailyTemperatures(temperatures []int) []int {
+    length:=len(temperatures)
+    res:=make([]int,length)
+    for i:=0;i<length;i++{
+        j:=i+1
+        if i==length-1{
+            res[i]=0
+        }
+        for j<length&&temperatures[i]>=temperatures[j]{//大于等于
+            j++
+        }
+        if j<length&&temperatures[i]<temperatures[j]{
+            res[i]=j-i
+        }
+        if j==length{
+            res[i]=0
+        }
+    }
+    return res
+}
+```
+
+> 单调栈法
+
+```go
+func dailyTemperatures(temperatures []int) []int {
+    length:=len(temperatures)
+    res:=make([]int,length)
+    stack:=[]int{}
+    for i:=0;i<length;i++{
+        //如果当前栈中存在元素，新来的元素大于栈顶的元素，则计算差值并弹出栈顶元素
+        for len(stack)>0&&temperatures[i]>temperatures[stack[len(stack)-1]]{
+            res[stack[len(stack)-1]]=i-stack[len(stack)-1]//存放结果集
+            stack=stack[:len(stack)-1]//删除stack[len(stack)-1]的元素
+        }
+        //如果栈顶元素大于等于新来的元素，则加入到栈中。当栈内元素个数为0时，直接入栈
+        if len(stack)==0||temperatures[i]<=temperatures[stack[len(stack)-1]]{
+            stack = append(stack, i)
+        }
+    }
+    return res
+}
+```
 
 
 
diff --git a/problems/0977.有序数组的平方.md b/problems/0977.有序数组的平方.md
index d2e1f950..0f9007d7 100644
--- a/problems/0977.有序数组的平方.md
+++ b/problems/0977.有序数组的平方.md
@@ -198,6 +198,31 @@ impl Solution {
     }
 }
 ```
+Javascript：
+```Javascript
+/**
+ * @desc two pointers solution
+ * @link https://leetcode-cn.com/problems/squares-of-a-sorted-array/
+ * @param nums Array  e.g. [-4,-1,0,3,10]
+ * @return {array}    e.g. [0,1,9,16,100]
+ */
+const sortedSquares = function (nums) {
+    let res = []
+    for (let i = 0, j = nums.length - 1; i <= j;) {
+      const left = Math.abs(nums[i])
+      const right = Math.abs(nums[j])
+      if (right > left) {
+        // push element to the front of the array
+        res.unshift(right * right)
+        j--
+      } else {
+        res.unshift(left * left)
+        i++
+      }
+    }
+    return res
+  }
+```
 
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
diff --git a/problems/背包问题理论基础多重背包.md b/problems/背包问题理论基础多重背包.md
index 26890a2b..e14575d4 100644
--- a/problems/背包问题理论基础多重背包.md
+++ b/problems/背包问题理论基础多重背包.md
@@ -147,9 +147,56 @@ int main() {
 
 Java：
 
-
 Python：
 
+```python
+def test_multi_pack1():
+    '''版本一：改变物品数量为01背包格式'''
+    weight = [1, 3, 4]
+    value = [15, 20, 30]
+    nums = [2, 3, 2]
+    bag_weight = 10
+    for i in range(len(nums)):
+        # 将物品展开数量为1
+        while nums[i] > 1:
+            weight.append(weight[i])
+            value.append(value[i])
+            nums[i] -= 1
+    
+    dp = [0]*(bag_weight + 1)
+    # 遍历物品
+    for i in range(len(weight)):
+        # 遍历背包
+        for j in range(bag_weight, weight[i] - 1, -1):
+            dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
+    
+    print(" ".join(map(str, dp)))
+
+def test_multi_pack2():
+    '''版本：改变遍历个数'''
+    weight = [1, 3, 4]
+    value = [15, 20, 30]
+    nums = [2, 3, 2]
+    bag_weight = 10
+
+    dp = [0]*(bag_weight + 1)
+    for i in range(len(weight)):
+        for j in range(bag_weight, weight[i] - 1, -1):
+            # 以上是01背包，加上遍历个数
+            for k in range(1, nums[i] + 1):
+                if j - k*weight[i] >= 0:
+                    dp[j] = max(dp[j], dp[j - k*weight[i]] + k*value[i])
+
+    print(" ".join(map(str, dp)))
+
+
+if __name__ == '__main__':
+    test_multi_pack1()
+    test_multi_pack2()
+```
+
+
+
 
 Go：