Merge branch 'youngyangyang04:master' into master

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/0028.实现strStr.md

@@ -1166,5 +1166,80 @@ func strStr(_ haystack: String, _ needle: String) -> Int {
 
 ```
 
+PHP：
+
+> 前缀表统一减一
+```php
+function strStr($haystack, $needle) {
+    if (strlen($needle) == 0) return 0;
+    $next= [];
+    $this->getNext($next,$needle);
+
+    $j = -1;
+    for ($i = 0;$i < strlen($haystack); $i++) { // 注意i就从0开始
+        while($j >= 0 && $haystack[$i] != $needle[$j + 1]) {
+            $j = $next[$j];
+        }
+        if ($haystack[$i] == $needle[$j + 1]) {
+            $j++;
+        }
+        if ($j == (strlen($needle) - 1) ) {
+            return ($i - strlen($needle) + 1);
+        }
+    }
+    return -1;
+}
+
+function getNext(&$next, $s){
+    $j = -1;
+    $next[0] = $j;
+    for($i = 1; $i < strlen($s); $i++) { // 注意i从1开始
+        while ($j >= 0 && $s[$i] != $s[$j + 1]) {
+            $j = $next[$j];
+        }
+        if ($s[$i] == $s[$j + 1]) {
+            $j++;
+        }
+        $next[$i] = $j;
+    }
+}
+```
+
+> 前缀表统一不减一
+```php
+function strStr($haystack, $needle) {
+    if (strlen($needle) == 0) return 0;
+    $next= [];
+    $this->getNext($next,$needle);
+
+    $j = 0;
+    for ($i = 0;$i < strlen($haystack); $i++) { // 注意i就从0开始
+        while($j > 0 && $haystack[$i] != $needle[$j]) {
+            $j = $next[$j-1];
+        }
+        if ($haystack[$i] == $needle[$j]) {
+            $j++;
+        }
+        if ($j == strlen($needle)) {
+            return ($i - strlen($needle) + 1);
+        }
+    }
+    return -1;
+}
+
+function getNext(&$next, $s){
+    $j = 0;
+    $next[0] = $j;
+    for($i = 1; $i < strlen($s); $i++) { // 注意i从1开始
+        while ($j > 0 && $s[$i] != $s[$j]) {
+            $j = $next[$j-1];
+        }
+        if ($s[$i] == $s[$j]) {
+            $j++;
+        }
+        $next[$i] = $j;
+    }
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0056.合并区间.md

@@ -96,7 +96,7 @@ public:
     vector<vector<int>> merge(vector<vector<int>>& intervals) {
         vector<vector<int>> result;
         if (intervals.size() == 0) return result;
-        // 排序的参数使用了lamda表达式
+        // 排序的参数使用了lambda表达式
         sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b){return a[0] < b[0];});
 
         result.push_back(intervals[0]);

problems/0151.翻转字符串里的单词.md

@@ -758,7 +758,63 @@ func reverseWord(_ s: inout [Character]) {
 }
 ```
 
+Scala:
 
+```scala
+object Solution {
+  def reverseWords(s: String): String = {
+    var sb = removeSpace(s) // 移除多余的空格
+    reverseString(sb, 0, sb.length - 1) // 翻转字符串
+    reverseEachWord(sb)
+    sb.mkString
+  }
+
+  // 移除多余的空格
+  def removeSpace(s: String): Array[Char] = {
+    var start = 0
+    var end = s.length - 1
+    // 移除字符串前面的空格
+    while (start < s.length && s(start) == ' ') start += 1
+    // 移除字符串后面的空格
+    while (end >= 0 && s(end) == ' ') end -= 1
+    var sb = "" // String
+    // 当start小于等于end的时候，执行添加操作
+    while (start <= end) {
+      var c = s(start)
+      // 当前字符不等于空，sb的最后一个字符不等于空的时候添加到sb
+      if (c != ' ' || sb(sb.length - 1) != ' ') {
+        sb ++= c.toString
+      }
+      start += 1 // 指针向右移动
+    }
+    sb.toArray
+  }
+
+  // 翻转字符串
+  def reverseString(s: Array[Char], start: Int, end: Int): Unit = {
+    var (left, right) = (start, end)
+    while (left < right) {
+      var tmp = s(left)
+      s(left) = s(right)
+      s(right) = tmp
+      left += 1
+      right -= 1
+    }
+  }
+
+  // 翻转每个单词
+  def reverseEachWord(s: Array[Char]): Unit = {
+    var i = 0
+    while (i < s.length) {
+      var j = i + 1
+      // 向后迭代寻找每个单词的坐标
+      while (j < s.length && s(j) != ' ') j += 1
+      reverseString(s, i, j - 1)  // 翻转每个单词
+      i = j + 1   // i往后更新
+    }
+  }
+}
+```
 
 
 

problems/0203.移除链表元素.md

@@ -266,6 +266,27 @@ public ListNode removeElements(ListNode head, int val) {
     }
     return head;
 }
+/**
+ * 不添加虚拟节点and pre Node方式
+ * 时间复杂度 O(n)
+ * 空间复杂度 O(1)
+ * @param head
+ * @param val
+ * @return
+ */
+public ListNode removeElements(ListNode head, int val) {
+    while(head!=null && head.val==val){
+        head = head.next;
+    }
+    ListNode curr = head;
+    while(curr!=null){
+        while(curr.next!=null && curr.next.val == val){
+            curr.next = curr.next.next;
+        }
+        curr = curr.next;
+    }
+    return head;
+}
 ```
 
 Python：

problems/0225.用队列实现栈.md

@@ -815,6 +815,89 @@ class MyStack {
     }
 }
 ```
+Scala:
 
+使用两个队列模拟栈:
+```scala
+import scala.collection.mutable
+
+class MyStack() {
+
+  val queue1 = new mutable.Queue[Int]()
+  val queue2 = new mutable.Queue[Int]()
+
+  def push(x: Int) {
+    queue1.enqueue(x)
+  }
+
+  def pop(): Int = {
+    var size = queue1.size
+    // 将queue1中的每个元素都移动到queue2
+    for (i <- 0 until size - 1) {
+      queue2.enqueue(queue1.dequeue())
+    }
+    var res = queue1.dequeue()
+    // 再将queue2中的每个元素都移动到queue1
+    while (!queue2.isEmpty) {
+      queue1.enqueue(queue2.dequeue())
+    }
+    res
+  }
+
+  def top(): Int = {
+    var size = queue1.size
+    for (i <- 0 until size - 1) {
+      queue2.enqueue(queue1.dequeue())
+    }
+    var res = queue1.dequeue()
+    while (!queue2.isEmpty) {
+      queue1.enqueue(queue2.dequeue())
+    }
+    // 最终还需要把res送进queue1
+    queue1.enqueue(res)
+    res
+  }
+
+  def empty(): Boolean = {
+    queue1.isEmpty
+  }
+}
+```
+使用一个队列模拟:
+```scala
+import scala.collection.mutable
+
+class MyStack() {
+
+  val queue = new mutable.Queue[Int]()
+
+  def push(x: Int) {
+    queue.enqueue(x)
+  }
+
+  def pop(): Int = {
+    var size = queue.size
+    for (i <- 0 until size - 1) {
+      queue.enqueue(queue.head) // 把头添到队列最后
+      queue.dequeue() // 再出队
+    }
+    queue.dequeue()
+  }
+
+  def top(): Int = {
+    var size = queue.size
+    var res = 0
+    for (i <- 0 until size) {
+      queue.enqueue(queue.head) // 把头添到队列最后
+      res = queue.dequeue() // 再出队
+    }
+    res
+  }
+
+  def empty(): Boolean = {
+    queue.isEmpty
+  }
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0232.用栈实现队列.md

@@ -495,6 +495,45 @@ void myQueueFree(MyQueue* obj) {
     obj->stackOutTop = 0;
 }
 ```
+Scala:
+```scala
+class MyQueue() {
+  import scala.collection.mutable
+  val stackIn = mutable.Stack[Int]() // 负责出栈
+  val stackOut = mutable.Stack[Int]() // 负责入栈
 
+  // 添加元素
+  def push(x: Int) {
+    stackIn.push(x)
+  }
+
+  // 复用代码，如果stackOut为空就把stackIn的所有元素都压入StackOut
+  def dumpStackIn(): Unit = {
+    if (!stackOut.isEmpty) return
+    while (!stackIn.isEmpty) {
+      stackOut.push(stackIn.pop())
+    }
+  }
+
+  // 弹出元素
+  def pop(): Int = {
+    dumpStackIn()
+    stackOut.pop()
+  }
+
+  // 获取队头
+  def peek(): Int = {
+    dumpStackIn()
+    val res: Int = stackOut.pop()
+    stackOut.push(res)
+    res
+  }
+
+  // 判断是否为空
+  def empty(): Boolean = {
+    stackIn.isEmpty && stackOut.isEmpty
+  }
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0404.左叶子之和.md

@@ -336,8 +336,8 @@ var sumOfLeftLeaves = function(root) {
         if(node===null){
             return 0;
         }
-        let leftValue = sumOfLeftLeaves(node.left);
-        let rightValue = sumOfLeftLeaves(node.right);
+        let leftValue = nodesSum(node.left);
+        let rightValue = nodesSum(node.right);
         // 3. 单层递归逻辑
         let midValue = 0;
         if(node.left&&node.left.left===null&&node.left.right===null){

problems/0516.最长回文子序列.md

@@ -186,29 +186,28 @@ class Solution:
 Go：
 ```Go
 func longestPalindromeSubseq(s string) int {
-	lenth:=len(s)
-	dp:=make([][]int,lenth)
-	for i:=0;i<lenth;i++{
-		for j:=0;j<lenth;j++{
-			if dp[i]==nil{
-				dp[i]=make([]int,lenth)
+	size := len(s)
+	max := func(a, b int) int {
+		if a > b {
+			return a
 		}
-			if i==j{
-				dp[i][j]=1
+		return b
 	}
+	dp := make([][]int, size)
+	for i := 0; i < size; i++ {
+		dp[i] = make([]int, size)
+		dp[i][i] = 1
 	}
-	}
-	for i:=lenth-1;i>=0;i--{
-		for j:=i+1;j<lenth;j++{
+	for i := size - 1; i >= 0; i-- {
+		for j := i + 1; j < size; j++ {
 			if s[i] == s[j] {
 				dp[i][j] = dp[i+1][j-1] + 2
 			} else {
-				dp[i][j]=max(dp[i+1][j],dp[i][j-1])
+				dp[i][j] = max(dp[i][j-1], dp[i+1][j])
 			}
 		}
 	}
-
-	return dp[0][lenth-1]
+	return dp[0][size-1]
 }
 ```
 

problems/0739.每日温度.md

@@ -34,7 +34,8 @@
 
 那么单调栈的原理是什么呢？为什么时间复杂度是O(n)就可以找到每一个元素的右边第一个比它大的元素位置呢？
 
-单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素大的元素，优点是只需要遍历一次。
+
+单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素高的元素，优点是只需要遍历一次。
 
 
 在使用单调栈的时候首先要明确如下几点：
@@ -192,7 +193,7 @@ class Solution {
         否则的话，可以直接入栈。
         注意，单调栈里 加入的元素是 下标。
         */
-        Stack<Integer>stack=new Stack<>();
+        Deque<Integer> stack=new LinkedList<>();
         stack.push(0);
         for(int i=1;i<lens;i++){
             
@@ -216,7 +217,7 @@ class Solution {
     public int[] dailyTemperatures(int[] temperatures) {
         int lens=temperatures.length;
         int []res=new int[lens];
-        Stack<Integer>stack=new Stack<>();
+        Deque<Integer> stack=new LinkedList<>();
         for(int i=0;i<lens;i++){
             
            while(!stack.isEmpty()&&temperatures[i]>temperatures[stack.peek()]){

problems/1047.删除字符串中的所有相邻重复项.md

@@ -374,6 +374,27 @@ func removeDuplicates(_ s: String) -> String {
     return String(stack)
 }
 ```
-
+Scala:
+```scala
+object Solution {
+  import scala.collection.mutable
+  def removeDuplicates(s: String): String = {
+    var stack = mutable.Stack[Int]()
+    var str = "" // 保存最终结果
+    for (i <- s.indices) {
+      var tmp = s(i)
+      // 如果栈非空并且栈顶元素等于当前字符，那么删掉栈顶和字符串最后一个元素
+      if (!stack.isEmpty && tmp == stack.head) {
+        str = str.take(str.length - 1)
+        stack.pop()
+      } else {
+        stack.push(tmp)
+        str += tmp
+      }
+    }
+    str
+  }
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/剑指Offer58-II.左旋转字符串.md

@@ -291,6 +291,56 @@ func reverseString(_ s: inout [Character], startIndex: Int, endIndex: Int)  {
 ```
 
 
+### PHP
+
+```php
+function reverseLeftWords($s, $n) {
+    $this->reverse($s,0,$n-1); //反转区间为前n的子串
+    $this->reverse($s,$n,strlen($s)-1); //反转区间为n到末尾的子串
+    $this->reverse($s,0,strlen($s)-1); //反转整个字符串
+    return $s;
+}
+
+// 按指定进行翻转 【array、string都可】
+function reverse(&$s, $start, $end) {
+    for ($i = $start, $j = $end; $i < $j; $i++, $j--) {
+        $tmp = $s[$i];
+        $s[$i] = $s[$j];
+        $s[$j] = $tmp;
+    }
+}
+```
+
+
+Scala:
+
+```scala
+object Solution {
+  def reverseLeftWords(s: String, n: Int): String = {
+    var str = s.toCharArray // 转换为Array
+    // abcdefg => ba cdefg 
+    reverseString(str, 0, n - 1)
+    // ba cdefg => ba gfedc
+    reverseString(str, n, str.length - 1)
+    // ba gfedc => cdefgab
+    reverseString(str, 0, str.length - 1)
+    // 最终返回，return关键字可以省略
+    new String(str)
+  }
+  // 翻转字符串
+  def reverseString(s: Array[Char], start: Int, end: Int): Unit = {
+    var (left, right) = (start, end)
+    while (left < right) {
+      var tmp = s(left)
+      s(left) = s(right)
+      s(right) = tmp
+      left += 1
+      right -= 1
+    }
+  }
+}
+```
+