diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md
index 52735794..4b17c972 100644
--- a/problems/0019.删除链表的倒数第N个节点.md
+++ b/problems/0019.删除链表的倒数第N个节点.md
@@ -184,6 +184,25 @@ var removeNthFromEnd = function(head, n) {
     return ret.next;
 };
 ```
+Kotlin:
+```Kotlin
+fun removeNthFromEnd(head: ListNode?, n: Int): ListNode? {
+    val pre = ListNode(0).apply {
+        this.next = head
+    }
+    var fastNode: ListNode? = pre
+    var slowNode: ListNode? = pre
+    for (i in 0..n) {
+        fastNode = fastNode?.next
+    }
+    while (fastNode != null) {
+        slowNode = slowNode?.next
+        fastNode = fastNode.next
+    }
+    slowNode?.next = slowNode?.next?.next
+    return pre.next
+}
+```
 
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
diff --git a/problems/0024.两两交换链表中的节点.md b/problems/0024.两两交换链表中的节点.md
index b285b2d4..cae69cea 100644
--- a/problems/0024.两两交换链表中的节点.md
+++ b/problems/0024.两两交换链表中的节点.md
@@ -228,6 +228,27 @@ var swapPairs = function (head) {
 };
 ```
 
+Kotlin:
+
+```kotlin
+fun swapPairs(head: ListNode?): ListNode? {
+    val dummyNode = ListNode(0).apply { 
+        this.next = head
+    }
+    var cur: ListNode? = dummyNode
+    while (cur?.next != null && cur.next?.next != null) {
+        val temp = cur.next
+        val temp2 = cur.next?.next?.next
+        cur.next = cur.next?.next
+        cur.next?.next = temp
+        cur.next?.next?.next = temp2
+        cur = cur.next?.next
+    }
+    return dummyNode.next
+}
+```
+
+
 
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
diff --git a/problems/0046.全排列.md b/problems/0046.全排列.md
index 3ee7271e..3b3ba180 100644
--- a/problems/0046.全排列.md
+++ b/problems/0046.全排列.md
@@ -227,24 +227,27 @@ class Solution:
 
 Go：
 ```Go
-var result [][]int
-func backtrack(nums,pathNums []int,used []bool){
-    if len(nums)==len(pathNums){
-        tmp:=make([]int,len(nums))
-        copy(tmp,pathNums)
-        result=append(result,tmp)
-        //result=append(result,pathNums)
-        return 
-    }
-    for i:=0;i<len(nums);i++{
-        if !used[i]{
-            used[i]=true
-            pathNums=append(pathNums,nums[i])
-            backtrack(nums,pathNums,used)
-            pathNums=pathNums[:len(pathNums)-1]
-            used[i]=false
-        }
-    }
+var res [][]int
+func permute(nums []int) [][]int {
+	res = [][]int{}
+	backTrack(nums,len(nums),[]int{})
+	return res
+}
+func backTrack(nums []int,numsLen int,path []int)  {
+	if len(nums)==0{
+		p:=make([]int,len(path))
+		copy(p,path)
+		res = append(res,p)
+	}
+	for i:=0;i<numsLen;i++{
+		cur:=nums[i]
+		path = append(path,cur)
+		nums = append(nums[:i],nums[i+1:]...)//直接使用切片
+		backTrack(nums,len(nums),path)
+		nums = append(nums[:i],append([]int{cur},nums[i:]...)...)//回溯的时候切片也要复原，元素位置不能变
+		path = path[:len(path)-1]
+
+	}
 }
 
 ```
diff --git a/problems/0047.全排列II.md b/problems/0047.全排列II.md
index 66107c95..c8764241 100644
--- a/problems/0047.全排列II.md
+++ b/problems/0047.全排列II.md
@@ -228,35 +228,31 @@ Go：
 ```go
 var res [][]int
 func permute(nums []int) [][]int {
-    res = [][]int{}
-    sort.Ints(nums)
-    dfs(nums, make([]int, 0), make([]bool, len(nums)))
-    return res
+	res = [][]int{}
+	backTrack(nums,len(nums),[]int{})
+	return res
 }
+func backTrack(nums []int,numsLen int,path []int)  {
+	if len(nums)==0{
+		p:=make([]int,len(path))
+		copy(p,path)
+		res = append(res,p)
+	}
+	used := [21]int{}//跟前一题唯一的区别，同一层不使用重复的数。关于used的思想carl在递增子序列那一题中提到过
+	for i:=0;i<numsLen;i++{
+		if used[nums[i]+10]==1{
+			continue
+		}
+		cur:=nums[i]
+		path = append(path,cur)
+		used[nums[i]+10]=1
+		nums = append(nums[:i],nums[i+1:]...)
+		backTrack(nums,len(nums),path)
+		nums = append(nums[:i],append([]int{cur},nums[i:]...)...)
+		path = path[:len(path)-1]
 
-func dfs(nums, path []int, used []bool) {
-    if len(path) == len(nums) {
-        res = append(res, append([]int{}, path...))
-        return
-    }
+	}
 
-    m := make(map[int]bool)
-    for i := 0; i < len(nums); i++ {
-        // used 从剩余 nums 中选
-        if used[i] {
-            continue
-        }
-        // m 集合间去重
-        if _, ok := m[nums[i]]; ok {
-            continue
-        }
-        m[nums[i]] = true
-        path = append(path, nums[i])
-        used[i] = true
-        dfs(nums, path, used)
-        used[i] = false
-        path = path[:len(path)-1]
-    }
 }
 ```
 
diff --git a/problems/0206.翻转链表.md b/problems/0206.翻转链表.md
index 4efdda3b..27a2e903 100644
--- a/problems/0206.翻转链表.md
+++ b/problems/0206.翻转链表.md
@@ -319,7 +319,20 @@ def reverse(pre, cur)
   reverse(cur, tem)	# 通过递归实现双指针法中的更新操作
 end
 ```
-
+Kotlin:
+```Kotlin
+fun reverseList(head: ListNode?): ListNode? {
+    var pre: ListNode? = null
+    var cur = head
+    while (cur != null) {
+        val temp = cur.next
+        cur.next = pre
+        pre = cur
+        cur = temp
+    }
+    return pre
+}
+```
 
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
diff --git a/problems/0236.二叉树的最近公共祖先.md b/problems/0236.二叉树的最近公共祖先.md
index 7b5deb56..41e12df4 100644
--- a/problems/0236.二叉树的最近公共祖先.md
+++ b/problems/0236.二叉树的最近公共祖先.md
@@ -249,7 +249,6 @@ class Solution {
 ```java
 // 代码精简版
 class Solution {
-    TreeNode pre;
     public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
         if (root == null || root.val == p.val ||root.val == q.val) return root;
         TreeNode left = lowestCommonAncestor(root.left,p,q);
diff --git a/problems/0349.两个数组的交集.md b/problems/0349.两个数组的交集.md
index 5c635d39..5dc18478 100644
--- a/problems/0349.两个数组的交集.md
+++ b/problems/0349.两个数组的交集.md
@@ -127,7 +127,7 @@ class Solution:
         for num in nums2:
             if num in set1:
                 result_set.add(num) # set1里出现的nums2元素 存放到结果
-        return result_set
+        return list(result_set)
 ```
 
 
diff --git a/problems/0406.根据身高重建队列.md b/problems/0406.根据身高重建队列.md
index a5f66a5d..699f67d0 100644
--- a/problems/0406.根据身高重建队列.md
+++ b/problems/0406.根据身高重建队列.md
@@ -217,7 +217,25 @@ class Solution:
 ```
 
 Go：
-
+```golang
+func reconstructQueue(people [][]int) [][]int {
+    //先将身高从大到小排序，确定最大个子的相对位置
+    sort.Slice(people,func(i,j int)bool{
+        if people[i][0]==people[j][0]{
+            return people[i][1]<people[j][1]//这个才是当身高相同时，将K按照从小到大排序
+        }
+        return people[i][0]>people[j][0]//这个只是确保身高按照由大到小的顺序来排，并不确定K是按照从小到大排序的
+    })
+    //再按照K进行插入排序，优先插入K小的
+    result := make([][]int, 0)
+	for _, info := range people {
+		result = append(result, info)
+		copy(result[info[1] +1:], result[info[1]:])//将插入位置之后的元素后移动一位（意思是腾出空间）
+		result[info[1]] = info//将插入元素位置插入元素
+	}
+	return result
+}
+```
 Javascript:
 ```Javascript
 var reconstructQueue = function(people) {
diff --git a/problems/0450.删除二叉搜索树中的节点.md b/problems/0450.删除二叉搜索树中的节点.md
index 4695ed50..e6ce469e 100644
--- a/problems/0450.删除二叉搜索树中的节点.md
+++ b/problems/0450.删除二叉搜索树中的节点.md
@@ -320,6 +320,7 @@ class Solution:
 
 Go：
 ```Go
+// 递归版本
 func deleteNode(root *TreeNode, key int) *TreeNode {
     if root==nil{
         return nil
@@ -356,6 +357,51 @@ func deleteNode1(root *TreeNode)*TreeNode{
     root.Left=deleteNode1(root.Left)
     return root
 }
+// 迭代版本
+func deleteOneNode(target *TreeNode) *TreeNode {
+	if target == nil {
+		return target
+	}
+	if target.Right == nil {
+		return target.Left
+	}
+	cur := target.Right
+	for cur.Left != nil {
+		cur = cur.Left
+	}
+	cur.Left = target.Left
+	return target.Right
+}
+func deleteNode(root *TreeNode, key int) *TreeNode {
+	// 特殊情况处理
+	if root == nil {
+		return root
+	}
+	cur := root
+	var pre *TreeNode
+	for cur != nil {
+		if cur.Val == key {
+			break
+		}
+		pre = cur
+		if cur.Val > key {
+			cur = cur.Left
+		} else {
+			cur = cur.Right
+		}
+	}
+	if pre == nil {
+		return deleteOneNode(cur)
+	}
+	// pre 要知道是删除左孩子还有右孩子
+	if pre.Left != nil && pre.Left.Val == key {
+		pre.Left = deleteOneNode(cur)
+	}
+	if pre.Right != nil && pre.Right.Val == key {
+		pre.Right = deleteOneNode(cur)
+	}
+	return root
+}
 ```
 
 JavaScript版本
diff --git a/problems/0513.找树左下角的值.md b/problems/0513.找树左下角的值.md
index 27c6e83c..7e48b53c 100644
--- a/problems/0513.找树左下角的值.md
+++ b/problems/0513.找树左下角的值.md
@@ -9,6 +9,8 @@
 
 ## 513.找树左下角的值
 
+题目地址：[https://leetcode-cn.com/problems/find-bottom-left-tree-value/](https://leetcode-cn.com/problems/find-bottom-left-tree-value/v)
+
 给定一个二叉树，在树的最后一行找到最左边的值。
 
 示例 1:
diff --git a/problems/0617.合并二叉树.md b/problems/0617.合并二叉树.md
index 09d844f3..2900a817 100644
--- a/problems/0617.合并二叉树.md
+++ b/problems/0617.合并二叉树.md
@@ -426,6 +426,46 @@ func mergeTrees(root1 *TreeNode, root2 *TreeNode) *TreeNode {
     root1.Right = mergeTrees(root1.Right, root2.Right)
     return root1
 }
+
+// 迭代版本
+func mergeTrees(root1 *TreeNode, root2 *TreeNode) *TreeNode {
+    queue := make([]*TreeNode,0)
+    if root1 == nil{
+        return root2
+    }
+    if root2 == nil{
+        return root1
+    }
+    queue = append(queue,root1)
+    queue = append(queue,root2)
+
+    for size:=len(queue);size>0;size=len(queue){
+        node1 := queue[0]
+        queue = queue[1:]
+        node2 := queue[0]
+        queue = queue[1:]
+        node1.Val += node2.Val
+        // 左子树都不为空
+        if node1.Left != nil && node2.Left != nil{
+            queue = append(queue,node1.Left)
+            queue = append(queue,node2.Left)
+        }
+        // 右子树都不为空
+        if node1.Right !=nil && node2.Right !=nil{
+            queue = append(queue,node1.Right)
+            queue = append(queue,node2.Right)
+        }
+        // 树 1 的左子树为 nil，直接接上树 2 的左子树
+        if node1.Left == nil{
+            node1.Left = node2.Left
+        }
+        // 树 1 的右子树为 nil，直接接上树 2 的右子树
+        if node1.Right == nil{
+            node1.Right = node2.Right
+        }
+    }
+    return root1
+}
 ```
 
 JavaScript:
diff --git a/problems/0707.设计链表.md b/problems/0707.设计链表.md
index 349e2409..5e748a24 100644
--- a/problems/0707.设计链表.md
+++ b/problems/0707.设计链表.md
@@ -880,7 +880,73 @@ MyLinkedList.prototype.deleteAtIndex = function(index) {
  * obj.deleteAtIndex(index)
  */
 ```
+Kotlin:
+```kotlin
+class MyLinkedList {
 
+    var next: ListNode? = null
+
+    var size: Int = 0
+
+    fun get(index: Int): Int {
+        if (index + 1 > size) return -1
+        var cur = this.next
+        for (i in 0 until index) {
+            cur = cur?.next
+        }
+        return cur?.`val` ?: -1
+    }
+
+    fun addAtHead(`val`: Int) {
+        val head = ListNode(`val`)
+        head.next = this.next
+        this.next = head
+        size++
+    }
+
+    fun addAtTail(`val`: Int) {
+        val pre = ListNode(0)
+        pre.next = this.next
+        var cur: ListNode? = pre
+        while (cur?.next != null) {
+            cur = cur.next
+        }
+        cur?.next = ListNode(`val`)
+        this.next = pre.next
+        size++
+    }
+
+    fun addAtIndex(index: Int, `val`: Int) {
+        if (index > size) return
+        val pre = ListNode(0)
+        pre.next = this.next
+        var cur:ListNode? = pre
+        for (i in 0 until index) {
+            cur = cur?.next
+        }
+        val temp = cur?.next
+        cur?.next = ListNode(`val`)
+        cur?.next?.next = temp
+        this.next = pre.next
+        size++
+    }
+
+    fun deleteAtIndex(index: Int) {
+        if (index + 1 > size) return
+        val pre = ListNode(0)
+        pre.next = this.next
+        var cur: ListNode? = pre
+        for (i in 0 until index) {
+            cur = cur?.next
+        }
+        val temp = cur?.next?.next
+        cur?.next?.next = null
+        cur?.next = temp
+        this.next = pre.next
+        size--
+    }
+}
+```
 
 
 
diff --git a/problems/1002.查找常用字符.md b/problems/1002.查找常用字符.md
index e3014d00..19f9e128 100644
--- a/problems/1002.查找常用字符.md
+++ b/problems/1002.查找常用字符.md
@@ -169,6 +169,29 @@ class Solution {
     }
 }
 ```
+```python
+class Solution:
+    def commonChars(self, words: List[str]) -> List[str]:
+        if not words: return []
+        result = []
+        hash = [0] * 26 # 用来统计所有字符串里字符出现的最小频率
+        for i, c in enumerate(words[0]):  # 用第一个字符串给hash初始化
+            hash[ord(c) - ord('a')] += 1
+        # 统计除第一个字符串外字符的出现频率
+        for i in range(1, len(words)):
+            hashOtherStr = [0] * 26
+            for j in range(len(words[0])):
+                hashOtherStr[ord(words[i][j]) - ord('a')] += 1
+            # 更新hash，保证hash里统计26个字符在所有字符串里出现的最小次数
+            for k in range(26):
+                hash[k] = min(hash[k], hashOtherStr[k])
+        # 将hash统计的字符次数，转成输出形式
+        for i in range(26):
+            while hash[i] != 0: # 注意这里是while，多个重复的字符
+                result.extend(chr(i + ord('a')))
+                hash[i] -= 1
+        return result
+```
 javaScript
 ```js
 var commonChars = function (words) {
diff --git a/problems/1207.独一无二的出现次数.md b/problems/1207.独一无二的出现次数.md
index c1720430..32aa3c3a 100644
--- a/problems/1207.独一无二的出现次数.md
+++ b/problems/1207.独一无二的出现次数.md
@@ -100,7 +100,21 @@ class Solution {
 ```
 
 Python：
-
+```python
+class Solution:
+    def uniqueOccurrences(self, arr: List[int]) -> bool:
+        count = [0] * 2002
+        for i in range(len(arr)):
+            count[arr[i] + 1000] += 1 # 防止负数作为下标
+        freq = [False] * 1002 # 标记相同频率是否重复出现
+        for i in range(2001):
+            if count[i] > 0:
+                if freq[count[i]] == False:
+                    freq[count[i]] = True
+                else:
+                    return False
+        return True
+```
 Go：
 
 JavaScript：