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

Author: youngyangyang04

problems/0018.四数之和.md

@@ -35,7 +35,7 @@
 
 四数之和，和[15.三数之和](https://programmercarl.com/0015.三数之和.html)是一个思路，都是使用双指针法, 基本解法就是在[15.三数之和](https://programmercarl.com/0015.三数之和.html) 的基础上再套一层for循环。
 
-但是有一些细节需要注意，例如： 不要判断`nums[k] > target` 就返回了，三数之和 可以通过 `nums[i] > 0` 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是`[-4, -3, -2, -1]`，`target`是`-10`，不能因为`-4 > -10`而跳过。但是我们依旧可以去做剪枝，逻辑变成`nums[i] > target && (nums[i] >=0 || target >= 0)`就可以了。
+但是有一些细节需要注意，例如： 不要判断`nums[k] > target` 就返回了，三数之和 可以通过 `nums[i] > 0` 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是`[-4, -3, -2, -1]`，`target`是`-10`，不能因为`-4 > -10`而跳过。但是我们依旧可以去做剪枝，逻辑变成`nums[k] > target && (nums[k] >=0 || target >= 0)`就可以了。
 
 [15.三数之和](https://programmercarl.com/0015.三数之和.html)的双指针解法是一层for循环num[i]为确定值，然后循环内有left和right下标作为双指针，找到nums[i] + nums[left] + nums[right] == 0。
 
@@ -253,7 +253,7 @@ public class Solution {
         for (int k = 0; k < nums.length; k++) {
             // 剪枝处理
             if (nums[k] > target && nums[k] >= 0) {
-                break;
+                break;	// 此处的break可以等价于return result;
             }
             // 对nums[k]去重
             if (k > 0 && nums[k] == nums[k - 1]) {
@@ -262,7 +262,7 @@ public class Solution {
             for (int i = k + 1; i < nums.length; i++) {
                 // 第二级剪枝
                 if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
-                    break;
+                    break;	// 注意是break到上一级for循环，如果直接return result;会有遗漏
                 }
                 // 对nums[i]去重
                 if (i > k + 1 && nums[i] == nums[i - 1]) {
@@ -802,3 +802,4 @@ end
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+

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

@@ -129,6 +129,36 @@ class Solution {
 }
 ```
 
+
+```java
+class Solution {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        // 创建一个新的哑节点，指向原链表头  
+        ListNode s = new ListNode(-1, head);
+        // 递归调用remove方法，从哑节点开始进行删除操作  
+        remove(s, n);
+        // 返回新链表的头（去掉可能的哑节点）  
+        return s.next;
+    }
+    
+    public int remove(ListNode p, int n) {
+        // 递归结束条件：如果当前节点为空，返回0  
+        if (p == null) {
+            return 0;
+        }
+        // 递归深入到下一个节点  
+        int net = remove(p.next, n);
+        // 如果当前节点是倒数第n个节点，进行删除操作  
+        if (net == n) {
+            p.next = p.next.next;  
+        }
+        // 返回当前节点的总深度  
+        return net + 1;
+    }
+}
+```
+
+
 ### Python:
 
 ```python

problems/0020.有效的括号.md

@@ -166,12 +166,35 @@ class Solution {
                 deque.pop();
             }
         }
-        //最后判断栈中元素是否匹配
+        //遍历结束，如果栈为空，则括号全部匹配
         return deque.isEmpty();
     }
 }
 ```
 
+```java
+// 解法二
+// 对应的另一半一定在栈顶
+class Solution {
+    public boolean isValid(String s) {
+        Stack<Character> stack = new Stack<>();
+        for(char c : s.toCharArray()){
+            // 有对应的另一半就直接消消乐
+            if(c == ')' && !stack.isEmpty() && stack.peek() == '(')
+                stack.pop();
+            else if(c == '}' && !stack.isEmpty() && stack.peek() == '{')
+                stack.pop();
+            else if(c == ']' && !stack.isEmpty() && stack.peek() == '[')
+                stack.pop();
+            else
+                stack.push(c);// 没有匹配的就放进去
+        }
+
+        return stack.isEmpty();
+    }
+}
+```
+
 ### Python：
 
 ```python
@@ -555,3 +578,4 @@ impl Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+

problems/0059.螺旋矩阵II.md

@@ -715,26 +715,65 @@ object Solution {
 ### C#：
 
 ```csharp
-public class Solution {
-    public int[][] GenerateMatrix(int n) {
-        int[][] answer = new int[n][];
-        for(int i = 0; i < n; i++)
-            answer[i] = new int[n];
-        int start = 0;
-        int end = n - 1;
-        int tmp = 1;
-        while(tmp < n * n)
+public int[][] GenerateMatrix(int n)
+{
+    // 参考Carl的代码随想录里面C++的思路
+    // https://www.programmercarl.com/0059.%E8%9E%BA%E6%97%8B%E7%9F%A9%E9%98%B5II.html#%E6%80%9D%E8%B7%AF
+    int startX = 0, startY = 0; // 定义每循环一个圈的起始位置
+    int loop = n / 2; // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
+    int count = 1; // 用来给矩阵每个空格赋值
+    int mid = n / 2; // 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
+    int offset = 1;// 需要控制每一条边遍历的长度，每次循环右边界收缩一位
+
+    // 构建result二维数组
+    int[][] result = new int[n][];
+    for (int k = 0; k < n; k++)
+    {
+        result[k] = new int[n];
+    }
+
+    int i = 0, j = 0; // [i,j]
+    while (loop > 0)
+    {
+        i = startX;
+        j = startY;
+        // 四个For循环模拟转一圈
+        // 第一排，从左往右遍历，不取最右侧的值(左闭右开)
+        for (; j < n - offset; j++)
+        {
+            result[i][j] = count++;
+        }
+        // 右侧的第一列，从上往下遍历，不取最下面的值(左闭右开)
+        for (; i < n - offset; i++)
+        {
+            result[i][j] = count++;
+        }
+
+        // 最下面的第一行，从右往左遍历，不取最左侧的值(左闭右开)
+        for (; j > startY; j--)
+        {
+            result[i][j] = count++;
+        }
+
+        // 左侧第一列，从下往上遍历，不取最左侧的值(左闭右开)
+        for (; i > startX; i--)
         {
-            for(int i = start; i < end; i++) answer[start][i] = tmp++;
-            for(int i = start; i < end; i++) answer[i][end] = tmp++;
-            for(int i = end; i > start; i--) answer[end][i] = tmp++;
-            for(int i = end; i > start; i--) answer[i][start] = tmp++;
-            start++;
-            end--;
-        }
-        if(n % 2 == 1) answer[n / 2][n / 2] = tmp;
-        return answer;
+            result[i][j] = count++;
+        }
+        // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
+        startX++;
+        startY++;
+
+        // offset 控制每一圈里每一条边遍历的长度
+        offset++;
+        loop--;
+    }
+    if (n % 2 == 1)
+    {
+        // n 为奇数
+        result[mid][mid] = count;
     }
+    return result;
 }
 ```
 

problems/0070.爬楼梯.md

@@ -130,8 +130,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(n)
 
 当然依然也可以，优化一下空间复杂度，代码如下：
 
@@ -154,8 +154,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
 
 后面将讲解的很多动规的题目其实都是当前状态依赖前两个，或者前三个状态，都可以做空间上的优化，**但我个人认为面试中能写出版本一就够了哈，清晰明了，如果面试官要求进一步优化空间的话，我们再去优化**。
 
@@ -524,3 +524,4 @@ impl Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+

problems/0102.二叉树的层序遍历.md

@@ -1231,6 +1231,47 @@ impl Solution {
 }
 ```
 
+#### C#:
+
+```C# 199.二叉树的右视图
+public class Solution
+{
+    public IList<int> RightSideView(TreeNode root)
+    {
+        var result = new List<int>();
+        Queue<TreeNode> queue = new();
+
+        if (root != null)
+        {
+            queue.Enqueue(root);
+        }
+        while (queue.Count > 0)
+        {
+            int count = queue.Count;
+            int lastValue = count - 1;
+            for (int i = 0; i < count; i++)
+            {
+                var currentNode = queue.Dequeue();
+                if (i == lastValue)
+                {
+                    result.Add(currentNode.val);
+                }
+
+                // lastValue == i == count -1 : left 先于 right 进入Queue
+                if (currentNode.left != null) queue.Enqueue(currentNode.left);
+                if (currentNode.right != null) queue.Enqueue(currentNode.right);
+
+                //// lastValue == i == 0: right 先于 left 进入Queue
+                // if(currentNode.right !=null ) queue.Enqueue(currentNode.right);
+                // if(currentNode.left !=null ) queue.Enqueue(currentNode.left);
+            }
+        }
+
+        return result;
+    }
+}
+```
+
 ## 637.二叉树的层平均值
 
 [力扣题目链接](https://leetcode.cn/problems/average-of-levels-in-binary-tree/)
@@ -1558,6 +1599,35 @@ impl Solution {
 }
 ```
 
+#### C#:
+
+```C# 二叉树的层平均值
+public class Solution {
+    public IList<double> AverageOfLevels(TreeNode root) {
+        var result= new List<double>();
+        Queue<TreeNode> queue = new();
+        if(root !=null) queue.Enqueue(root);
+        
+        while (queue.Count > 0)
+        {
+            int count = queue.Count;
+            double value=0;
+            for (int i = 0; i < count; i++)
+            {
+                var curentNode=queue.Dequeue();
+                value += curentNode.val;
+                if (curentNode.left!=null) queue.Enqueue(curentNode.left);
+                if (curentNode.right!=null) queue.Enqueue(curentNode.right);
+            }
+            result.Add(value/count);
+        }
+
+        return result;
+    }
+}
+
+```
+
 ## 429.N叉树的层序遍历
 
 [力扣题目链接](https://leetcode.cn/problems/n-ary-tree-level-order-traversal/)

problems/0111.二叉树的最小深度.md

@@ -40,7 +40,7 @@
 本题依然是前序遍历和后序遍历都可以，前序求的是深度，后序求的是高度。
 
 * 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
-* 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数后者节点数（取决于高度从0开始还是从1开始）
+* 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）
 
 那么使用后序遍历，其实求的是根节点到叶子节点的最小距离，就是求高度的过程，不过这个最小距离 也同样是最小深度。
 

problems/0150.逆波兰表达式求值.md

@@ -489,6 +489,67 @@ impl Solution {
 }
 ```
 
+### C:
+
+```c
+int str_to_int(char *str) {
+    // string转integer
+    int num = 0, tens = 1;
+    for (int i = strlen(str) - 1; i >= 0; i--) {
+        if (str[i] == '-') {
+            num *= -1;
+            break;
+        }
+        num += (str[i] - '0') * tens;
+        tens *= 10;
+    }
+    return num;
+}
+
+int evalRPN(char** tokens, int tokensSize) {
+
+    int *stack = (int *)malloc(tokensSize * sizeof(int));
+    assert(stack);
+    int stackTop = 0;
+
+    for (int i = 0; i < tokensSize; i++) {
+        char symbol = (tokens[i])[0];
+        if (symbol < '0' && (tokens[i])[1] == '\0') {
+
+            // pop两个数字
+            int num1 = stack[--stackTop];
+            int num2 = stack[--stackTop];
+
+            // 计算结果
+            int result;
+            if (symbol == '+') {
+                result = num1 + num2;
+            } else if (symbol == '-') {
+                result = num2 - num1;
+            } else if (symbol == '/') {
+                result = num2 / num1;
+            } else {
+                result = num1 * num2;
+            }
+
+            // push回stack
+            stack[stackTop++] = result;
+
+        } else {
+
+            // push数字进stack
+            int num = str_to_int(tokens[i]);
+            stack[stackTop++] = num;
+            
+        }
+    }
+
+    int result = stack[0];
+    free(stack);
+    return result;
+}
+```
+
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>