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

Author: KingArthur0205

README.md

@@ -254,7 +254,7 @@
 33. [二叉树：构造一棵搜索树](./problems/0108.将有序数组转换为二叉搜索树.md)
 34. [二叉树：搜索树转成累加树](./problems/0538.把二叉搜索树转换为累加树.md)
 35. [二叉树：总结篇！（需要掌握的二叉树技能都在这里了）](./problems/二叉树总结篇.md)
- 
+
 ## 回溯算法 
 
 题目分类大纲如下：             

problems/0001.两数之和.md

@@ -275,5 +275,48 @@ class Solution {
 }
 ```
 
+Scala:
+```scala
+object Solution {
+  // 导入包
+  import scala.collection.mutable
+  def twoSum(nums: Array[Int], target: Int): Array[Int] = {
+    // key存储值，value存储下标
+    val map = new mutable.HashMap[Int, Int]()
+    for (i <- nums.indices) {
+      val tmp = target - nums(i) // 计算差值
+      // 如果这个差值存在于map，则说明找到了结果
+      if (map.contains(tmp)) {
+        return Array(map.get(tmp).get, i)
+      }
+      // 如果不包含把当前值与其下标放到map
+      map.put(nums(i), i)
+    }
+    // 如果没有找到直接返回一个空的数组，return关键字可以省略
+    new Array[Int](2)
+  }
+}
+```
+
+C#:
+```csharp
+public class Solution {
+    public int[] TwoSum(int[] nums, int target) {
+        Dictionary<int ,int> dic= new Dictionary<int,int>();
+        for(int i=0;i<nums.Length;i++){
+            int imp= target-nums[i];
+            if(dic.ContainsKey(imp)&&dic[imp]!=i){
+               return new int[]{i, dic[imp]};
+            }
+            if(!dic.ContainsKey(nums[i])){
+                dic.Add(nums[i],i);
+            }
+        }
+        return new int[]{0, 0};
+    }
+}
+```
+
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0015.三数之和.md

@@ -616,6 +616,49 @@ public class Solution
     }
 }
 ```
-
+Scala:
+```scala
+object Solution {
+  // 导包
+  import scala.collection.mutable.ListBuffer
+  import scala.util.control.Breaks.{break, breakable}
+
+  def threeSum(nums: Array[Int]): List[List[Int]] = {
+    // 定义结果集，最后需要转换为List
+    val res = ListBuffer[List[Int]]()
+    val nums_tmp = nums.sorted // 对nums进行排序
+    for (i <- nums_tmp.indices) {
+      // 如果要排的第一个数字大于0，直接返回结果
+      if (nums_tmp(i) > 0) {
+        return res.toList
+      }
+      // 如果i大于0并且和前一个数字重复，则跳过本次循环，相当于continue
+      breakable {
+        if (i > 0 && nums_tmp(i) == nums_tmp(i - 1)) {
+          break
+        } else {
+          var left = i + 1
+          var right = nums_tmp.length - 1
+          while (left < right) {
+            var sum = nums_tmp(i) + nums_tmp(left) + nums_tmp(right) // 求三数之和
+            if (sum < 0) left += 1
+            else if (sum > 0) right -= 1
+            else {
+              res += List(nums_tmp(i), nums_tmp(left), nums_tmp(right)) // 如果等于0 添加进结果集
+              // 为了避免重复，对left和right进行移动
+              while (left < right && nums_tmp(left) == nums_tmp(left + 1)) left += 1
+              while (left < right && nums_tmp(right) == nums_tmp(right - 1)) right -= 1
+              left += 1
+              right -= 1
+            }
+          }
+        }
+      }
+    }
+    // 最终返回需要转换为List，return关键字可以省略
+    res.toList
+  }
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0018.四数之和.md

@@ -522,6 +522,49 @@ public class Solution
     }
 }
 ```
-
+Scala:
+```scala
+object Solution {
+  // 导包
+  import scala.collection.mutable.ListBuffer
+  import scala.util.control.Breaks.{break, breakable}
+  def fourSum(nums: Array[Int], target: Int): List[List[Int]] = {
+    val res = ListBuffer[List[Int]]()
+    val nums_tmp = nums.sorted // 先排序
+    for (i <- nums_tmp.indices) {
+      breakable {
+        if (i > 0 && nums_tmp(i) == nums_tmp(i - 1)) {
+          break // 如果该值和上次的值相同，跳过本次循环，相当于continue
+        } else {
+          for (j <- i + 1 until nums_tmp.length) {
+            breakable {
+              if (j > i + 1 && nums_tmp(j) == nums_tmp(j - 1)) {
+                break // 同上
+              } else {
+                // 双指针
+                var (left, right) = (j + 1, nums_tmp.length - 1)
+                while (left < right) {
+                  var sum = nums_tmp(i) + nums_tmp(j) + nums_tmp(left) + nums_tmp(right)
+                  if (sum == target) {
+                    // 满足要求，直接加入到集合里面去
+                    res += List(nums_tmp(i), nums_tmp(j), nums_tmp(left), nums_tmp(right))
+                    while (left < right && nums_tmp(left) == nums_tmp(left + 1)) left += 1
+                    while (left < right && nums_tmp(right) == nums_tmp(right - 1)) right -= 1
+                    left += 1
+                    right -= 1
+                  } else if (sum < target) left += 1
+                  else right -= 1
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    // 最终返回的res要转换为List，return关键字可以省略
+    res.toList
+  }
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0019.删除链表的倒数第N个节点.md

@@ -39,7 +39,7 @@
 
 分为如下几步：
 
-* 首先这里我推荐大家使用虚拟头结点，这样方面处理删除实际头结点的逻辑，如果虚拟头结点不清楚，可以看这篇： [链表：听说用虚拟头节点会方便很多？](https://programmercarl.com/0203.移除链表元素.html)
+* 首先这里我推荐大家使用虚拟头结点，这样方便处理删除实际头结点的逻辑，如果虚拟头结点不清楚，可以看这篇： [链表：听说用虚拟头节点会方便很多？](https://programmercarl.com/0203.移除链表元素.html)
 
 * 定义fast指针和slow指针，初始值为虚拟头结点，如图：
 
@@ -289,6 +289,28 @@ func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
     return dummyHead.next
 }
 ```
-
+Scala:
+```scala
+object Solution {
+  def removeNthFromEnd(head: ListNode, n: Int): ListNode = {
+    val dummy = new ListNode(-1, head) // 定义虚拟头节点
+    var fast = head // 快指针从头开始走
+    var slow = dummy // 慢指针从虚拟头开始头
+    // 因为参数 n 是不可变量，所以不能使用 while(n>0){n-=1}的方式
+    for (i <- 0 until n) {
+      fast = fast.next
+    }
+    // 快指针和满指针一起走，直到fast走到null
+    while (fast != null) {
+      slow = slow.next
+      fast = fast.next
+    }
+    // 删除slow的下一个节点 
+    slow.next = slow.next.next
+    // 返回虚拟头节点的下一个
+    dummy.next
+  }
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0020.有效的括号.md

@@ -400,6 +400,27 @@ bool isValid(char * s){
     return !stackTop;
 }
 ```
-
+Scala:
+```scala
+object Solution {
+  import scala.collection.mutable
+  def isValid(s: String): Boolean = {
+    if(s.length % 2 != 0) return false    // 如果字符串长度是奇数直接返回false
+    val stack = mutable.Stack[Char]()
+    // 循环遍历字符串
+    for (i <- s.indices) {
+      val c = s(i)
+      if (c == '(' || c == '[' || c == '{') stack.push(c)
+      else if(stack.isEmpty) return false   // 如果没有(、[、{则直接返回false
+      // 以下三种情况，不满足则直接返回false        
+      else if(c==')' && stack.pop() != '(') return false 
+      else if(c==']' && stack.pop() != '[') return false 
+      else if(c=='}' && stack.pop() != '{') return false 
+    }
+    // 如果为空则正确匹配，否则还有余孽就不匹配
+    stack.isEmpty
+  }
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0024.两两交换链表中的节点.md

@@ -311,7 +311,29 @@ func swapPairs(_ head: ListNode?) -> ListNode? {
     return dummyHead.next
 }
 ```
-
+Scala:
+```scala
+// 虚拟头节点
+object Solution {
+  def swapPairs(head: ListNode): ListNode = {
+    var dummy = new ListNode(0, head) // 虚拟头节点
+    var pre = dummy
+    var cur = head
+    // 当pre的下一个和下下个都不为空，才进行两两转换
+    while (pre.next != null && pre.next.next != null) {
+      var tmp: ListNode = cur.next.next // 缓存下一次要进行转换的第一个节点
+      pre.next = cur.next // 步骤一
+      cur.next.next = cur // 步骤二
+      cur.next = tmp // 步骤三
+      // 下面是准备下一轮的交换
+      pre = cur
+      cur = tmp
+    }
+    // 最终返回dummy虚拟头节点的下一个，return可以省略
+    dummy.next
+  }
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0027.移除元素.md

@@ -28,6 +28,8 @@
 
 ## 思路
 
+[本题B站视频讲解](https://www.bilibili.com/video/BV12A4y1Z7LP)
+
 有的同学可能说了，多余的元素，删掉不就得了。
 
 **要知道数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。**
@@ -75,13 +77,23 @@ public:
 
 双指针法（快慢指针法）： **通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。**
 
+定义快慢指针 
+
+* 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
+* 慢指针：指向更新 新数组下标的位置
+
+很多同学这道题目做的很懵，就是不理解 快慢指针究竟都是什么含义，所以一定要明确含义，后面的思路就更容易理解了。
+
 删除过程如下：
 
 ![27.移除元素-双指针法](https://tva1.sinaimg.cn/large/008eGmZEly1gntrds6r59g30du09mnpd.gif)
 
+很多同学不了解
+
+
 **双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。**
 
-后序都会一一介绍到，本题代码如下：
+后续都会一一介绍到，本题代码如下：
 
 ```CPP
 // 时间复杂度：O(n)
@@ -104,8 +116,6 @@ public:
 * 时间复杂度：O(n)
 * 空间复杂度：O(1)
 
-旧文链接：[数组：就移除个元素很难么？](https://programmercarl.com/0027.移除元素.html)
-
 ```CPP
 /**
 * 相向双指针方法，基于元素顺序可以改变的题目描述改变了元素相对位置，确保了移动最少元素
@@ -329,5 +339,34 @@ int removeElement(int* nums, int numsSize, int val){
 }
 ```
 
+
+Kotlin:
+```kotlin
+fun removeElement(nums: IntArray, `val`: Int): Int {
+        var slowIndex = 0 // 初始化慢指针
+        for (fastIndex in nums.indices) {
+            if (nums[fastIndex] != `val`) nums[slowIndex++] = nums[fastIndex] // 在慢指针所在位置存储未被删除的元素
+        }
+        return slowIndex
+    }
+```
+
+
+Scala:
+```scala
+object Solution {
+  def removeElement(nums: Array[Int], `val`: Int): Int = {
+    var slow = 0
+    for (fast <- 0 until nums.length) {
+      if (`val` != nums(fast)) {
+        nums(slow) = nums(fast)
+        slow += 1
+      }
+    }
+    slow
+  }
+}
+```
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>