Merge branch 'master' of https://github.com/youngyangyang04/leetcode-master

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)

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)

problems/0027.移除元素.md

@@ -216,6 +216,25 @@ fn main() {
     println!("{:?}",remove_element(&mut nums, 5));
 }
 ```
+
+Swift:
+
+```swift
+func removeElement(_ nums: inout [Int], _ val: Int) -> Int {
+    var slowIndex = 0
+
+    for fastIndex in 0..<nums.count {
+        if val != nums[fastIndex] {
+            if slowIndex != fastIndex {
+                nums[slowIndex] = nums[fastIndex]
+            }
+            slowIndex += 1
+        }
+    }
+    return slowIndex
+}
+```
+
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)

problems/0035.搜索插入位置.md

@@ -234,8 +234,6 @@ class Solution {
 ```
 
 
-
-
 Python：
 ```python3
 class Solution:
@@ -254,9 +252,6 @@ class Solution:
         return right + 1
 ```
 
-
-Go：
-
 JavaScript:
 ```js
 var searchInsert = function (nums, target) {
@@ -277,6 +272,42 @@ var searchInsert = function (nums, target) {
 };
 ```
 
+Swift:
+
+```swift
+// 暴力法
+func searchInsert(_ nums: [Int], _ target: Int) -> Int {
+    for i in 0..<nums.count {
+        if nums[i] >= target {
+            return i
+        }
+    }
+    return nums.count
+}
+
+// 二分法
+func searchInsert(_ nums: [Int], _ target: Int) -> Int {
+    var left = 0
+    var right = nums.count - 1
+
+    while left <= right {
+        let middle = left + ((right - left) >> 1)
+
+        if nums[middle] > target {
+            right = middle - 1
+        }else if nums[middle] < target {
+            left = middle + 1
+        }else if nums[middle] == target {
+            return middle
+        }
+    }
+
+    return right + 1
+}
+```
+
+
+
 
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)

problems/0046.全排列.md

@@ -227,23 +227,26 @@ class Solution:
 
 Go：
 ```Go
-var result [][]int
+var res [][]int
-func backtrack(nums,pathNums []int,used []bool){
+func permute(nums []int) [][]int {
-    if len(nums)==len(pathNums){
+	res = [][]int{}
-        tmp:=make([]int,len(nums))
+	backTrack(nums,len(nums),[]int{})
-        copy(tmp,pathNums)
+	return res
-        result=append(result,tmp)
+}
-        //result=append(result,pathNums)
+func backTrack(nums []int,numsLen int,path []int)  {
-        return 
+	if len(nums)==0{
-    }
+		p:=make([]int,len(path))
-    for i:=0;i<len(nums);i++{
+		copy(p,path)
-        if !used[i]{
+		res = append(res,p)
-            used[i]=true
-            pathNums=append(pathNums,nums[i])
-            backtrack(nums,pathNums,used)
-            pathNums=pathNums[:len(pathNums)-1]
-            used[i]=false
 	}
+	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]
+
 	}
 }
 

problems/0047.全排列II.md

@@ -229,34 +229,30 @@ Go：
 var res [][]int
 func permute(nums []int) [][]int {
 	res = [][]int{}
-    sort.Ints(nums)
+	backTrack(nums,len(nums),[]int{})
-    dfs(nums, make([]int, 0), make([]bool, len(nums)))
 	return res
 }
-
+func backTrack(nums []int,numsLen int,path []int)  {
-func dfs(nums, path []int, used []bool) {
+	if len(nums)==0{
-    if len(path) == len(nums) {
+		p:=make([]int,len(path))
-        res = append(res, append([]int{}, path...))
+		copy(p,path)
-        return
+		res = append(res,p)
 	}
-
+	used := [21]int{}//跟前一题唯一的区别，同一层不使用重复的数。关于used的思想carl在递增子序列那一题中提到过
-    m := make(map[int]bool)
+	for i:=0;i<numsLen;i++{
-    for i := 0; i < len(nums); i++ {
+		if used[nums[i]+10]==1{
-        // used 从剩余 nums 中选
-        if used[i] {
 			continue
 		}
-        // m 集合间去重
+		cur:=nums[i]
-        if _, ok := m[nums[i]]; ok {
+		path = append(path,cur)
-            continue
+		used[nums[i]+10]=1
-        }
+		nums = append(nums[:i],nums[i+1:]...)
-        m[nums[i]] = true
+		backTrack(nums,len(nums),path)
-        path = append(path, nums[i])
+		nums = append(nums[:i],append([]int{cur},nums[i:]...)...)
-        used[i] = true
-        dfs(nums, path, used)
-        used[i] = false
 		path = path[:len(path)-1]
+
 	}
+
 }
 ```
 

problems/0116.填充每个节点的下一个右侧节点指针.md

@@ -130,21 +130,47 @@ public:
 ## Java
 
 ```java
+
 ```
 
 ## Python
 
 ```python
+
 ```
 
 ## Go
 
 ```go
+
 ```
 
 ## JavaScript
 
 ```js
+const connect = root => {
+    if (!root) return root;
+    // 根节点入队
+    const Q = [root];
+    while (Q.length) {
+        const len = Q.length;
+        // 遍历这一层的所有节点
+        for (let i = 0; i < len; i++) {
+            // 队头出队
+            const node = Q.shift();
+            // 连接
+            if (i < len - 1) {
+                // 新的队头是node的右边元素
+                node.next = Q[0];
+            }
+            // 队头左节点有值，放入队列
+            node.left && Q.push(node.left);
+            // 队头右节点有值，放入队列
+            node.right && Q.push(node.right);
+        }
+    }
+    return root;
+};
 ```
 
 -----------------------

problems/0123.买卖股票的最佳时机III.md

@@ -278,7 +278,44 @@ class Solution:
         return dp[4]
 ```
 
-Go：
+JavaScript：
+
+> 版本一：
+
+```javascript
+const maxProfit = prices => {
+    const len = prices.length;
+    const dp = new Array(len).fill(0).map(x => new Array(5).fill(0));
+    dp[0][1] = -prices[0];
+    dp[0][3] = -prices[0];
+    for (let i = 1; i < len; i++) {
+        dp[i][0] = dp[i - 1][0];
+        dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
+        dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
+        dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
+        dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
+    }
+    return dp[len - 1][4];
+};
+```
+
+> 版本二：
+
+```javascript
+const maxProfit = prices => {
+    const len = prices.length;
+    const dp = new Array(5).fill(0);
+    dp[1] = -prices[0];
+    dp[3] = -prices[0];
+    for (let i = 1; i < len; i++) {
+        dp[1] = Math.max(dp[1], dp[0] - prices[i]);
+        dp[2] = Math.max(dp[2], dp[1] + prices[i]);
+        dp[3] = Math.max(dp[3], dp[2] - prices[i]);
+        dp[4] = Math.max(dp[4], dp[3] + prices[i]);
+    }
+    return dp[4];
+};
+```
 
 
 

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)

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);

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)
 ```
 
 

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) {

problems/0435.无重叠区间.md

@@ -250,7 +250,29 @@ class Solution:
 ```
 
 Go：
-
+```golang
+func eraseOverlapIntervals(intervals [][]int) int {
+    var flag int
+    //先排序
+    sort.Slice(intervals,func(i,j int)bool{
+        return intervals[i][0]<intervals[j][0]
+    })
+    fmt.Println(intervals)
+    for i:=1;i<len(intervals);i++{
+        if intervals[i-1][1]>intervals[i][0]{
+            flag++
+            intervals[i][1]=min(intervals[i-1][1],intervals[i][1])//由于是先排序的，所以，第一位是递增顺序，故只需要将临近两个元素的第二个值最小值更新到该元素的第二个值即可作之后的判断
+        }
+    }
+    return flag
+}
+func min(a,b int)int{
+    if a>b{
+        return b
+    }
+    return a
+}
+```
 Javascript:
 ```Javascript
 var eraseOverlapIntervals = function(intervals) {

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版本

problems/0452.用最少数量的箭引爆气球.md

@@ -175,6 +175,30 @@ class Solution:
 
 Go：
 
+```golang
+func findMinArrowShots(points [][]int) int {
+    var res int =1//弓箭数
+    //先按照第一位排序
+    sort.Slice(points,func (i,j int) bool{
+        return points[i][0]<points[j][0]
+    })
+
+    for i:=1;i<len(points);i++{
+        if points[i-1][1]<points[i][0]{//如果前一位的右边界小于后一位的左边界，则一定不重合
+            res++
+        }else{
+            points[i][1] = min(points[i - 1][1], points[i][1]); // 更新重叠气球最小右边界,覆盖该位置的值，留到下一步使用
+        }
+    }
+    return res
+}
+func min(a,b int) int{
+    if a>b{
+        return b
+    }
+    return a
+}
+```
 Javascript:
 ```Javascript
 var findMinArrowShots = function(points) {

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:

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:

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--
+    }
+}
+```
 
 
 

problems/0977.有序数组的平方.md

@@ -224,6 +224,36 @@ const sortedSquares = function (nums) {
   }
 ```
 
+Swift:
+
+```swift
+func sortedSquares(_ nums: [Int]) -> [Int] {
+    // 指向新数组最后一个元素
+    var k = nums.count - 1
+    // 指向原数组第一个元素
+    var i = 0
+    // 指向原数组最后一个元素
+    var j = nums.count - 1
+    // 初始化新数组(用-1填充)
+    var result = Array<Int>(repeating: -1, count: nums.count)
+
+    for _ in 0..<nums.count {
+        if nums[i] * nums[i] < nums[j] * nums[j] {
+            result[k] = nums[j] * nums[j]
+            j -= 1
+        } else {
+            result[k] = nums[i] * nums[i]
+            i += 1
+        }
+        k -= 1
+    }
+
+    return result
+}
+```
+
+
+
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)

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) {

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：

problems/1365.有多少小于当前数字的数字.md

@@ -139,7 +139,19 @@ public int[] smallerNumbersThanCurrent(int[] nums) {
 ```
 
 Python：
-
+```python
+class Solution:
+    def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
+        res = nums[:]
+        hash = dict()
+        res.sort() # 从小到大排序之后，元素下标就是小于当前数字的数字
+        for i, num in enumerate(res):
+            if num  not in hash.keys(): # 遇到了相同的数字，那么不需要更新该 number 的情况
+                hash[num] = i       
+        for i, num in enumerate(nums):
+            res[i] = hash[num]
+        return res
+```
 Go：
 
 JavaScript：