Merge branch 'master' into 添加0053最大子序和Go版本-1

2025-07-08 00:43:04 +08:00 · 2021-05-14 09:59:37 +08:00
parent 8fb528ec95 9ac7810711
commit cc012db90c
99 changed files with 3372 additions and 218 deletions
--- a/README.md
+++ b/README.md
@ -116,10 +116,11 @@
 1. [关于链表，你该了解这些！](./problems/链表理论基础.md)
 2. [链表：听说用虚拟头节点会方便很多？](./problems/0203.移除链表元素.md)
 3. [链表：一道题目考察了常见的五个操作！](./problems/0707.设计链表.md)
-4. [链表：听说过两天反转链表又写不出来了？](./problems/0206.翻转链表.md)
-5. [链表：删除链表的倒数第 N 个结点](./problems/0019.删除链表的倒数第N个节点.md)
-5. [链表：环找到了，那入口呢？](./problems/0142.环形链表II.md)
-6. [链表：总结篇！](./problems/链表总结篇.md)
+4. [链表：听说过两天反转链表又写不出来了？](./problems/0206.翻转链表.md) 
+5. [链表：两两交换链表中的节点](./problems/0024.两两交换链表中的节点.md)
+6. [链表：删除链表的倒数第 N 个结点](./problems/0019.删除链表的倒数第N个节点.md)
+7. [链表：环找到了，那入口呢？](./problems/0142.环形链表II.md)
+8. [链表：总结篇！](./problems/链表总结篇.md)

 ## 哈希表

--- a/problems/0017.电话号码的字母组合.md
+++ b/problems/0017.电话号码的字母组合.md
@ -240,7 +240,46 @@ public:


 Java：
+```Java
+class Solution {

+    //设置全局列表存储最后的结果
+    List<String> list = new ArrayList<>();
+
+    public List<String> letterCombinations(String digits) {
+        if (digits == null || digits.length() == 0) {
+            return list;
+        }
+        //初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""
+        String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+        //迭代处理
+        backTracking(digits, numString, 0);
+        return list;
+
+    }
+
+    //每次迭代获取一个字符串，所以会设计大量的字符串拼接，所以这里选择更为高效的 StringBuild
+    StringBuilder temp = new StringBuilder();
+
+    //比如digits如果为"23",num 为0，则str表示2对应的 abc
+    public void backTracking(String digits, String[] numString, int num) {
+        //遍历全部一次记录一次得到的字符串
+        if (num == digits.length()) {
+            list.add(temp.toString());
+            return;
+        }
+        //str 表示当前num对应的字符串
+        String str = numString[digits.charAt(num) - '0'];
+        for (int i = 0; i < str.length(); i++) {
+            temp.append(str.charAt(i));
+            //回溯
+            backTracking(digits, numString, num + 1);
+            //剔除末尾的继续尝试
+            temp.deleteCharAt(temp.length() - 1);
+        }
+    }
+}
+```

 Python：

--- a/problems/0020.有效的括号.md
+++ b/problems/0020.有效的括号.md
@ -138,7 +138,31 @@ public:


 Java：
-
+```Java
+class Solution {
+    public boolean isValid(String s) {
+        Deque<Character> deque = new LinkedList<>();
+        char ch;
+        for (int i = 0; i < s.length(); i++) {
+            ch = s.charAt(i);
+            //碰到左括号，就把相应的右括号入栈
+            if (ch == '(') {
+                deque.push(')');
+            }else if (ch == '{') {
+                deque.push('}');
+            }else if (ch == '[') {
+                deque.push(']');
+            } else if (deque.isEmpty() || deque.peek() != ch) {
+                return false;
+            }else {//如果是右括号判断是否和栈顶元素匹配
+                deque.pop();
+            }
+        }
+        //最后判断栈中元素是否匹配
+        return deque.isEmpty();
+    }
+}
+```

 Python：
 ```python3
@ -157,8 +181,44 @@ class Solution:
 ```

 Go：
+```Go
+func isValid(s string) bool {
+    hash := map[byte]byte{')':'(', ']':'[', '}':'{'}
+    stack := make([]byte, 0)
+    if s == "" {
+        return true
+    }

+    for i := 0; i < len(s); i++ {
+        if s[i] == '(' || s[i] == '[' || s[i] == '{' {
+            stack = append(stack, s[i])
+        } else if len(stack) > 0 && stack[len(stack)-1] == hash[s[i]] {
+            stack = stack[:len(stack)-1]
+        } else {
+            return false
+        }
+    }
+    return len(stack) == 0
+}
+```

+Ruby:
+```ruby
+def is_valid(strs)
+    symbol_map = {')' => '(', '}' => '{', ']' => '['}
+    stack = []
+    strs.size.times {|i|
+        c = strs[i]
+        if symbol_map.has_key?(c)
+            top_e = stack.shift
+            return false if symbol_map[c] != top_e
+        else
+            stack.unshift(c)
+        end
+    }
+    stack.empty?
+end
+```


 -----------------------
--- a/problems/0024.两两交换链表中的节点.md
+++ b/problems/0024.两两交换链表中的节点.md
@ -0,0 +1,100 @@
+
+<p align="center">
+  <a href="https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ"><img src="https://img.shields.io/badge/知识星球-代码随想录-blue" alt=""></a>
+  <a href="https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw"><img src="https://img.shields.io/badge/刷题-微信群-green" alt=""></a>
+  <a href="https://img-blog.csdnimg.cn/20201210231711160.png"><img src="https://img.shields.io/badge/公众号-代码随想录-brightgreen" alt=""></a>
+  <a href="https://space.bilibili.com/525438321"><img src="https://img.shields.io/badge/B站-代码随想录-orange" alt=""></a>
+</p>
+<p align="center"><strong>欢迎大家参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
+
+## 24. 两两交换链表中的节点
+
+给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
+
+你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
+
+
+<img src='https://code-thinking.cdn.bcebos.com/pics/24.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B9-%E9%A2%98%E6%84%8F.jpg' width=600 alt='24.两两交换链表中的节点-题意'> </img></div>
+
+## 思路
+
+这道题目正常模拟就可以了。
+
+建议使用虚拟头结点，这样会方便很多，要不然每次针对头结点（没有前一个指针指向头结点），还要单独处理。
+
+对虚拟头结点的操作，还不熟悉的话，可以看这篇[链表：听说用虚拟头节点会方便很多？](https://mp.weixin.qq.com/s/L5aanfALdLEwVWGvyXPDqA)。
+
+接下来就是交换相邻两个元素了，**此时一定要画图，不画图，操作多个指针很容易乱，而且要操作的先后顺序**
+
+初始时，cur指向虚拟头结点，然后进行如下三步：
+
+![24.两两交换链表中的节点1](https://code-thinking.cdn.bcebos.com/pics/24.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B91.png)
+
+操作之后，链表如下：
+
+![24.两两交换链表中的节点2](https://code-thinking.cdn.bcebos.com/pics/24.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B92.png)
+
+看这个可能就更直观一些了：
+
+
+![24.两两交换链表中的节点3](https://code-thinking.cdn.bcebos.com/pics/24.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B93.png)
+
+对应的C++代码实现如下： （注释中详细和如上图中的三步做对应）
+
+```C++
+class Solution {
+public:
+    ListNode* swapPairs(ListNode* head) {
+        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
+        dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
+        ListNode* cur = dummyHead;
+        while(cur->next != nullptr && cur->next->next != nullptr) {
+            ListNode* tmp = cur->next; // 记录临时节点
+            ListNode* tmp1 = cur->next->next->next; // 记录临时节点
+
+            cur->next = cur->next->next;    // 步骤一
+            cur->next->next = tmp;          // 步骤二
+            cur->next->next->next = tmp1;   // 步骤三
+
+            cur = cur->next->next; // cur移动两位，准备下一轮交换
+        }
+        return dummyHead->next;
+    }
+};
+```
+* 时间复杂度：$O(n)$
+* 空间复杂度：$O(1)$
+
+## 拓展
+
+**这里还是说一下，大家不必太在意力扣上执行用时，打败多少多少用户，这个统计不准确的。**
+
+做题的时候自己能分析出来时间复杂度就可以了，至于力扣上执行用时，大概看一下就行。
+
+上面的代码我第一次提交执行用时8ms，打败6.5%的用户，差点吓到我了。
+
+心想应该没有更好的方法了吧，也就O(n)的时间复杂度，重复提交几次，这样了：
+
+![24.两两交换链表中的节点](https://code-thinking.cdn.bcebos.com/pics/24.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B9.png)
+
+力扣上的统计如果两份代码是 100ms 和 300ms的耗时，其实是需要注意的。
+
+如果一个是 4ms 一个是 12ms，看上去好像是一个打败了80%，一个打败了20%，其实是没有差别的。 只不过是力扣上统计的误差而已。
+
+
+## 其他语言版本
+
+
+Java：
+
+
+Python：
+
+Go：
+
+
+-----------------------
+* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
+* B站视频：[代码随想录](https://space.bilibili.com/525438321)
+* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0027.移除元素.md
+++ b/problems/0027.移除元素.md
@ -123,10 +123,38 @@ public:


 Java：
+```java
+class Solution {
+    public int removeElement(int[] nums, int val) {

+        // 快慢指针
+        int fastIndex = 0;
+        int slowIndex;
+        for (slowIndex = 0; fastIndex < nums.length; fastIndex++) {
+            if (nums[fastIndex] != val) {
+                nums[slowIndex] = nums[fastIndex];
+                slowIndex++;
+            }
+        }
+        return slowIndex;
+
+    }
+}
+```

 Python：

+```python
+class Solution:
+    def removeElement(self, nums: List[int], val: int) -> int:
+        i,n = 0,len(nums)
+        for j in range(n):
+            if nums[j] != val:
+                nums[i] = nums[j]
+                i += 1
+        return i
+```
+

 Go：
 ```go
--- a/problems/0028.实现strStr.md
+++ b/problems/0028.实现strStr.md
@ -565,6 +565,54 @@ public:

 Java：

+```Java
+class Solution {
+    /**
+     * 基于窗口滑动的算法
+     * <p>
+     * 时间复杂度：O(m*n)
+     * 空间复杂度：O(1)
+     * 注：n为haystack的长度，m为needle的长度
+     */
+    public int strStr(String haystack, String needle) {
+        int m = needle.length();
+        // 当 needle 是空字符串时我们应当返回 0
+        if (m == 0) {
+            return 0;
+        }
+        int n = haystack.length();
+        if (n < m) {
+            return -1;
+        }
+        int i = 0;
+        int j = 0;
+        while (i < n - m + 1) {
+            // 找到首字母相等
+            while (i < n && haystack.charAt(i) != needle.charAt(j)) {
+                i++;
+            }
+            if (i == n) {// 没有首字母相等的
+                return -1;
+            }
+            // 遍历后续字符，判断是否相等
+            i++;
+            j++;
+            while (i < n && j < m && haystack.charAt(i) == needle.charAt(j)) {
+                i++;
+                j++;
+            }
+            if (j == m) {// 找到
+                return i - j;
+            } else {// 未找到
+                i -= j - 1;
+                j = 0;
+            }
+        }
+        return -1;
+    }
+}
+```
+
 ```java
 // 方法一
 class Solution {
--- a/problems/0035.搜索插入位置.md
+++ b/problems/0035.搜索插入位置.md
@ -237,6 +237,22 @@ class Solution {


 Python：
+```python3
+class Solution:
+    def searchInsert(self, nums: List[int], target: int) -> int:
+        left, right = 0, len(nums) - 1 
+        
+        while left <= right:
+            middle = (left + right) // 2
+            
+            if nums[middle] < target:
+                left = middle + 1
+            elif nums[middle] > target:
+                right = middle - 1
+            else: 
+                return middle
+        return right + 1
+```


 Go：
--- a/problems/0037.解数独.md
+++ b/problems/0037.解数独.md
@ -219,7 +219,72 @@ public:


 Java：
+```java
+class Solution {
+    public void solveSudoku(char[][] board) {
+        solveSudokuHelper(board);
+    }

+    private boolean solveSudokuHelper(char[][] board){
+        //「一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，
+        // 一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！」
+        for (int i = 0; i < 9; i++){ // 遍历行
+            for (int j = 0; j < 9; j++){ // 遍历列
+                if (board[i][j] != '.'){ // 跳过原始数字
+                    continue;
+                }
+                for (char k = '1'; k <= '9'; k++){ // (i, j) 这个位置放k是否合适
+                    if (isValidSudoku(i, j, k, board)){
+                        board[i][j] = k;
+                        if (solveSudokuHelper(board)){ // 如果找到合适一组立刻返回
+                            return true;
+                        }
+                        board[i][j] = '.';
+                    }
+                }
+                // 9个数都试完了，都不行，那么就返回false
+                return false;
+                // 因为如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！
+                // 那么会直接返回， 「这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去！」
+            }
+        }
+        // 遍历完没有返回false，说明找到了合适棋盘位置了
+        return true;
+    }
+
+    /**
+     * 判断棋盘是否合法有如下三个维度:
+     *     同行是否重复
+     *     同列是否重复
+     *     9宫格里是否重复
+     */
+    private boolean isValidSudoku(int row, int col, char val, char[][] board){
+        // 同行是否重复
+        for (int i = 0; i < 9; i++){
+            if (board[row][i] == val){
+                return false;
+            }
+        }
+        // 同列是否重复
+        for (int j = 0; j < 9; j++){
+            if (board[j][col] == val){
+                return false;
+            }
+        }
+        // 9宫格里是否重复
+        int startRow = (row / 3) * 3;
+        int startCol = (col / 3) * 3;
+        for (int i = startRow; i < startRow + 3; i++){
+            for (int j = startCol; j < startCol + 3; j++){
+                if (board[i][j] == val){
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+```

 Python：

--- a/problems/0039.组合总和.md
+++ b/problems/0039.组合总和.md
@ -236,7 +236,39 @@ public:


 Java：
+```Java
+class Solution {
+    List<List<Integer>> lists = new ArrayList<>();
+    Deque<Integer> deque = new LinkedList<>();

+    public List<List<Integer>> combinationSum3(int k, int n) {
+        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
+        backTracking(arr, n, k, 0);
+        return lists;
+    }
+
+    public void backTracking(int[] arr, int n, int k, int startIndex) {
+        //如果 n 小于0，没必要继续本次递归，已经不符合要求了
+        if (n < 0) {
+            return;
+        }
+        if (deque.size() == k) {
+            if (n == 0) {
+                lists.add(new ArrayList(deque));
+            }
+            return;
+        }
+        for (int i = startIndex; i < arr.length - (k - deque.size()) + 1; i++) {
+            deque.push(arr[i]);
+            //减去当前元素
+            n -= arr[i];
+            backTracking(arr, n, k, i + 1);
+            //恢复n
+            n += deque.pop();
+        }
+    }
+}
+```

 Python：

--- a/problems/0040.组合总和II.md
+++ b/problems/0040.组合总和II.md
@ -255,7 +255,43 @@ public:


 Java：
+```Java
+class Solution {
+    List<List<Integer>> lists = new ArrayList<>();
+    Deque<Integer> deque = new LinkedList<>();
+    int sum = 0;

+    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        //为了将重复的数字都放到一起，所以先进行排序
+        Arrays.sort(candidates);
+        //加标志数组，用来辅助判断同层节点是否已经遍历
+        boolean[] flag = new boolean[candidates.length];
+        backTracking(candidates, target, 0, flag);
+        return lists;
+    }
+
+    public void backTracking(int[] arr, int target, int index, boolean[] flag) {
+        if (sum == target) {
+            lists.add(new ArrayList(deque));
+            return;
+        }
+        for (int i = index; i < arr.length && arr[i] + sum <= target; i++) {
+            //出现重复节点，同层的第一个节点已经被访问过，所以直接跳过
+            if (i > 0 && arr[i] == arr[i - 1] && !flag[i - 1]) {
+                continue;
+            }
+            flag[i] = true;
+            sum += arr[i];
+            deque.push(arr[i]);
+            //每个节点仅能选择一次，所以从下一位开始
+            backTracking(arr, target, i + 1, flag);
+            int temp = deque.pop();
+            flag[i] = false;
+            sum -= temp;
+        }
+    }
+}
+```

 Python：

--- a/problems/0045.跳跃游戏II.md
+++ b/problems/0045.跳跃游戏II.md
@ -143,7 +143,36 @@ public:


 Java：
-
+```Java
+class Solution {
+    public int jump(int[] nums) {
+        if (nums == null || nums.length == 0 || nums.length == 1) {
+            return 0;
+        }
+        //记录跳跃的次数
+        int count=0;
+        //当前的覆盖最大区域
+        int curDistance = 0;
+        //最大的覆盖区域
+        int maxDistance = 0;
+        for (int i = 0; i < nums.length; i++) {
+            //在可覆盖区域内更新最大的覆盖区域
+            maxDistance = Math.max(maxDistance,i+nums[i]);
+            //说明当前一步，再跳一步就到达了末尾
+            if (maxDistance>=nums.length-1){
+                count++;
+                break;
+            }
+            //走到当前覆盖的最大区域时，更新下一步可达的最大区域
+            if (i==curDistance){
+                curDistance = maxDistance;
+                count++;
+            }
+        }
+        return count;
+    }
+}
+```

 Python：

--- a/problems/0046.全排列.md
+++ b/problems/0046.全排列.md
@ -147,7 +147,41 @@ public:


 Java：
+```java
+class Solution {
+    List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
+    LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
+    boolean[] used;
+    public List<List<Integer>> permute(int[] nums) {
+        if (nums.length == 0){
+            return result;
+        }
+        used = new boolean[nums.length];
+        permuteHelper(nums);
+        return result;
+    }

+    private void permuteHelper(int[] nums){
+        if (path.size() == nums.length){
+            result.add(new ArrayList<>(path));
+            return;
+        }
+        for (int i = 0; i < nums.length; i++){
+            // if (path.contains(nums[i])){
+            //     continue;
+            // }
+            if (used[i]){
+                continue;
+            }
+            used[i] = true;
+            path.add(nums[i]);
+            permuteHelper(nums);
+            path.removeLast();
+            used[i] = false;
+        }
+    }
+}
+```

 Python：

--- a/problems/0053.最大子序和.md
+++ b/problems/0053.最大子序和.md
@ -139,10 +139,40 @@ public:


 Java：
-
+```java
+class Solution {
+    public int maxSubArray(int[] nums) {
+        if (nums.length == 1){
+            return nums[0];
+        }
+        int sum = Integer.MIN_VALUE;
+        int count = 0;
+        for (int i = 0; i < nums.length; i++){
+            count += nums[i];
+            sum = Math.max(sum, count); // 取区间累计的最大值（相当于不断确定最大子序终止位置）
+            if (count <= 0){
+                count = 0; // 相当于重置最大子序起始位置，因为遇到负数一定是拉低总和
+            }
+        }
+       return sum;
+    }
+}
+```

 Python：
-
+```python
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        result = -float('inf')
+        count = 0
+        for i in range(len(nums)):
+            count += nums[i]
+            if count > result:
+                result = count
+            if count <= 0:
+                count = 0
+        return result
+```

 Go：
 ```Go
@ -170,7 +200,6 @@ func max(a,b int)int{
 ```


-
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
--- a/problems/0055.跳跃游戏.md
+++ b/problems/0055.跳跃游戏.md
@ -86,10 +86,40 @@ public:


 Java：
-
+```Java
+class Solution {
+    public boolean canJump(int[] nums) {
+        if (nums.length == 1) {
+            return true;
+        }
+        //覆盖范围
+        int coverRange = nums[0];
+        //在覆盖范围内更新最大的覆盖范围
+        for (int i = 0; i <= coverRange; i++) {
+            coverRange = Math.max(coverRange, i + nums[i]);
+            if (coverRange >= nums.length - 1) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+```

 Python：
-
+```python
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        cover = 0
+        if len(nums) == 1: return True
+        i = 0
+        # python不支持动态修改for循环中变量,使用while循环代替
+        while i <= cover:
+            cover = max(i + nums[i], cover)
+            if cover >= len(nums) - 1: return True
+            i += 1
+        return False
+```

 Go：

--- a/problems/0056.合并区间.md
+++ b/problems/0056.合并区间.md
@ -137,7 +137,35 @@ public:


 Java：
+```java
+class Solution {
+    public int[][] merge(int[][] intervals) {
+        List<int[]> res = new LinkedList<>();
+        Arrays.sort(intervals, new Comparator<int[]>() {
+            @Override
+            public int compare(int[] o1, int[] o2) {
+                if (o1[0] != o2[0]) {
+                    return Integer.compare(o1[0],o2[0]);
+                } else {
+                    return Integer.compare(o1[1],o2[1]);
+                }
+            }
+        });

+        int start = intervals[0][0];
+        for (int i = 1; i < intervals.length; i++) {
+            if (intervals[i][0] > intervals[i - 1][1]) {
+                res.add(new int[]{start, intervals[i - 1][1]});
+                start = intervals[i][0];
+            } else {
+                intervals[i][1] = Math.max(intervals[i][1], intervals[i - 1][1]);
+            }
+        }
+        res.add(new int[]{start, intervals[intervals.length - 1][1]});
+        return res.toArray(new int[res.size()][]);
+    }
+}
+```

 Python：

@ -151,4 +179,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0070.爬楼梯.md
+++ b/problems/0070.爬楼梯.md
@ -230,7 +230,20 @@ class Solution:
 ```

 Go：
-
+```Go
+func climbStairs(n int) int {
+    if n==1{
+        return 1
+    }
+    dp:=make([]int,n+1)
+    dp[1]=1
+    dp[2]=2
+    for i:=3;i<=n;i++{
+        dp[i]=dp[i-1]+dp[i-2]
+    }
+    return dp[n]
+}
+```



--- a/problems/0070.爬楼梯完全背包版本.md
+++ b/problems/0070.爬楼梯完全背包版本.md
@ -127,7 +127,23 @@ public:


 Java：
+```java
+class Solution {
+    public int climbStairs(int n) {
+        int[] dp = new int[n + 1];
+        int[] weight = {1,2};
+        dp[0] = 1;

+        for (int i = 0; i <= n; i++) {
+            for (int j = 0; j < weight.length; j++) {
+                if (i >= weight[j]) dp[i] += dp[i - weight[j]];
+            }
+        }
+
+        return dp[n];
+    }
+}
+```

 Python：

@ -141,4 +157,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0077.组合.md
+++ b/problems/0077.组合.md
@ -340,6 +340,33 @@ public:


 Java：
+```java
+class Solution {
+    List<List<Integer>> result = new ArrayList<>();
+    LinkedList<Integer> path = new LinkedList<>();
+    public List<List<Integer>> combine(int n, int k) {
+        combineHelper(n, k, 1);
+        return result;
+    }
+
+    /**
+     * 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
+     * @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
+     */
+    private void combineHelper(int n, int k, int startIndex){
+        //终止条件
+        if (path.size() == k){
+            result.add(new ArrayList<>(path));
+            return;
+        }
+        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++){
+            path.add(i);
+            combineHelper(n, k, i + 1);
+            path.removeLast();
+        }
+    }
+}
+```


 Python：
--- a/problems/0077.组合优化.md
+++ b/problems/0077.组合优化.md
@ -147,7 +147,33 @@ public:


 Java：
+```
+class Solution {
+    List<List<Integer>> result = new ArrayList<>();
+    LinkedList<Integer> path = new LinkedList<>();
+    public List<List<Integer>> combine(int n, int k) {
+        combineHelper(n, k, 1);
+        return result;
+    }

+    /**
+     * 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
+     * @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
+     */
+    private void combineHelper(int n, int k, int startIndex){
+        //终止条件
+        if (path.size() == k){
+            result.add(new ArrayList<>(path));
+            return;
+        }
+        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++){
+            path.add(i);
+            combineHelper(n, k, i + 1);
+            path.removeLast();
+        }
+    }
+}
+```

 Python：

--- a/problems/0078.子集.md
+++ b/problems/0078.子集.md
@ -177,14 +177,79 @@ public:


 Java：
+```java
+class Solution {
+    List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
+    LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
+    public List<List<Integer>> subsets(int[] nums) {
+        if (nums.length == 0){
+            result.add(new ArrayList<>());
+            return result;
+        }
+        Arrays.sort(nums);
+        subsetsHelper(nums, 0);
+        return result;
+    }

+    private void subsetsHelper(int[] nums, int startIndex){
+        result.add(new ArrayList<>(path));//「遍历这个树的时候，把所有节点都记录下来，就是要求的子集集合」。
+        if (startIndex >= nums.length){ //终止条件可不加
+            return;
+        }
+        for (int i = startIndex; i < nums.length; i++){
+            path.add(nums[i]);
+            subsetsHelper(nums, i + 1);
+            path.removeLast();
+        }
+    }
+}
+```

 Python：


 Go：
+```Go
+var res [][]int
+func subset(nums []int) [][]int {
+	res = make([][]int, 0)
+	sort.Ints(nums)
+	Dfs([]int{}, nums, 0)
+	return res
+}
+func Dfs(temp, nums []int, start int){
+	tmp := make([]int, len(temp))
+	copy(tmp, temp)
+	res = append(res, tmp)
+	for i := start; i < len(nums); i++{
+		//if i>start&&nums[i]==nums[i-1]{
+		//	continue
+		//}
+		temp = append(temp, nums[i])
+		Dfs(temp, nums, i+1)
+		temp = temp[:len(temp)-1]
+	}
+}
+```

+Javascript:

+```Javascript
+var subsets = function(nums) {
+    let result = []
+    let path = []
+    function backtracking(startIndex) {
+        result.push(path.slice())
+        for(let i = startIndex; i < nums.length; i++) {
+            path.push(nums[i])
+            backtracking(i + 1)
+            path.pop()
+        }
+    }
+    backtracking(0)
+    return result
+};
+```


 -----------------------
--- a/problems/0090.子集II.md
+++ b/problems/0090.子集II.md
@ -172,13 +172,69 @@ if (i > startIndex && nums[i] == nums[i - 1] ) {


 Java：
-
+```java
+class Solution {
+   List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
+   LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
+   boolean[] used;
+    public List<List<Integer>> subsetsWithDup(int[] nums) {
+        if (nums.length == 0){
+            result.add(path);
+            return result;
+        }
+        Arrays.sort(nums);
+        used = new boolean[nums.length];
+        subsetsWithDupHelper(nums, 0);
+        return result;
+    }
+    
+    private void subsetsWithDupHelper(int[] nums, int startIndex){
+        result.add(new ArrayList<>(path));
+        if (startIndex >= nums.length){
+            return;
+        }
+        for (int i = startIndex; i < nums.length; i++){
+            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]){
+                continue;
+            }
+            path.add(nums[i]);
+            used[i] = true;
+            subsetsWithDupHelper(nums, i + 1);
+            path.removeLast();
+            used[i] = false;
+        }
+    }
+}
+```

 Python：


 Go：
+```Go
+var res[][]int
+func subsetsWithDup(nums []int)[][]int {
+	res=make([][]int,0)
+	 sort.Ints(nums)
+	dfs([]int{},nums,0)
+	return res
+}

+func dfs(temp, num []int, start int)  {
+	tmp:=make([]int,len(temp))
+	copy(tmp,temp)
+
+	res=append(res,tmp)
+	for i:=start;i<len(num);i++{
+		if i>start&&num[i]==num[i-1]{
+			continue
+		}
+		temp=append(temp,num[i])
+		dfs(temp,num,i+1)
+		temp=temp[:len(temp)-1]
+	}
+}
+```



--- a/problems/0096.不同的二叉搜索树.md
+++ b/problems/0096.不同的二叉搜索树.md
@ -165,7 +165,25 @@ public:


 Java：
-
+```Java
+class Solution {
+    public int numTrees(int n) {
+        //初始化 dp 数组
+        int[] dp = new int[n + 1];
+        //初始化0个节点和1个节点的情况
+        dp[0] = 1;
+        dp[1] = 1;
+        for (int i = 2; i <= n; i++) {
+            for (int j = 1; j <= i; j++) {
+                //对于第i个节点，需要考虑1作为根节点直到i作为根节点的情况，所以需要累加
+                //一共i个节点，对于根节点j时,左子树的节点个数为j-1，右子树的节点个数为i-j
+                dp[i] += dp[j - 1] * dp[i - j];
+            }
+        }
+        return dp[n];
+    }
+}
+```

 Python：

--- a/problems/0098.验证二叉搜索树.md
+++ b/problems/0098.验证二叉搜索树.md
@ -254,13 +254,44 @@ public:


 Java：
+```java
+class Solution {
+    public boolean isValidBST(TreeNode root) {
+        return isValidBST_2(root, Long.MIN_VALUE, Long.MAX_VALUE);
+    }
+
+    public boolean isValidBST_2 (TreeNode root, long lo, long hi) {
+        if (root == null) return true;
+        if (root.val >= hi || root.val <= lo) return false;
+        return isValidBST_2(root.left,lo,root.val) && isValidBST_2(root.right,root.val,hi);
+    }
+}
+```


 Python：


 Go：
+```Go
+import "math"

+func isValidBST(root *TreeNode) bool {
+	if root == nil {
+		return true
+	}
+	return isBST(root, math.MinInt64, math.MaxFloat64)
+}
+func isBST(root *TreeNode, min, max int) bool {
+	if root == nil {
+		return true
+	}
+	if min >= root.Val || max <= root.Val {
+		return false
+	}
+	return isBST(root.Left, min, root.Val) && isBST(root.Right, root.Val, max)
+}
+```



@ -268,4 +299,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0101.对称二叉树.md
+++ b/problems/0101.对称二叉树.md
@ -253,9 +253,95 @@ public:

 ## 其他语言版本

-
 Java：
+```java
+public class N0101 {
+    /**
+     * 解法1：DFS，递归。
+     */
+    public boolean isSymmetric2(TreeNode root) {
+        if (root == null) {
+            return false;
+        }

+        return compare(root.left, root.right);
+    }
+
+    private boolean compare(TreeNode left, TreeNode right) {
+        if (left == null && right == null) {
+            return true;
+        }
+        if (left != null && right == null) {
+            return false;
+        }
+        if (left == null && right != null) {
+            return false;
+        }
+
+        if (left.val == right.val) {
+            return compare(left.left, right.right) && compare(left.right, right.left);
+        }
+
+        return false;
+    }
+
+    /**
+     * 解法2：DFS，迭代
+     */
+    public boolean isSymmetric3(TreeNode root) {
+        if (root == null) {
+            return false;
+        }
+
+        if (!equal(root.left, root.right)) {
+            return false;
+        }
+
+        Deque<TreeNode> st = new LinkedList<>();
+
+        st.push(root.right);
+        st.push(root.left);
+
+        TreeNode curR = root.right;
+        TreeNode curL = root.left;
+
+        while (!st.isEmpty()) {
+            curL = st.pop();
+            curR = st.pop();
+
+            // 前序，处理
+            if (!equal(curL, curR)) {
+                return false;
+            }
+
+            if (curR != null && curL != null) {
+                st.push(curL.right);
+                st.push(curR.left);
+                st.push(curR.right);
+                st.push(curL.left);
+            }
+        }
+
+        return true;
+    }
+
+    private boolean equal(TreeNode l, TreeNode r) {
+        if (l == null && r == null) {
+            return true;
+        }
+        if (l != null && r == null) {
+            return false;
+        }
+        if (l == null && r != null) {
+            return false;
+        }
+        if (l.val == r.val) {
+            return true;
+        }
+        return false;
+    }
+}
+```

 Python：

--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@ -419,35 +419,237 @@ public:

 Java：

-``` Java
-
-
+```Java
+// 102.二叉树的层序遍历
 class Solution {
-    public List<List<Integer>> resList=new ArrayList<List<Integer>>();
+    public List<List<Integer>> resList = new ArrayList<List<Integer>>();
+
    public List<List<Integer>> levelOrder(TreeNode root) {
-        checkFun01(root,0);
+        //checkFun01(root,0);
+        checkFun02(root);

        return resList;
    }

-	//递归方式
-    public void checkFun01(TreeNode node,Integer deep){
-        if(node==null) return;
+    //DFS--递归方式
+    public void checkFun01(TreeNode node, Integer deep) {
+        if (node == null) return;
        deep++;

-        if(resList.size()<deep){
+        if (resList.size() < deep) {
            //当层级增加时，list的Item也增加，利用list的索引值进行层级界定
-            List<Integer> item=new ArrayList<Integer>();
+            List<Integer> item = new ArrayList<Integer>();
            resList.add(item);
        }
-        resList.get(deep-1).add(node.val);
-        
+        resList.get(deep - 1).add(node.val);

-        checkFun01(node.left,deep);
-        checkFun01(node.right,deep);
+        checkFun01(node.left, deep);
+        checkFun01(node.right, deep);
    }

+    //BFS--迭代方式--借助队列
+    public void checkFun02(TreeNode node) {
+        if (node == null) return;
+        Queue<TreeNode> que = new LinkedList<TreeNode>();
+        que.offer(node);

+        while (!que.isEmpty()) {
+            List<Integer> itemList = new ArrayList<Integer>();
+            int len = que.size();
+
+            while (len > 0) {
+                TreeNode tmpNode = que.poll();
+                itemList.add(tmpNode.val);
+
+                if (tmpNode.left != null) que.offer(tmpNode.left);
+                if (tmpNode.right != null) que.offer(tmpNode.right);
+                len--;
+            }
+
+            resList.add(itemList);
+        }
+
+    }
+}
+    
+
+// 107. 二叉树的层序遍历 II
+public class N0107 {
+
+    /**
+     * 解法：队列，迭代。
+     * 层序遍历，再翻转数组即可。
+     */
+    public List<List<Integer>> solution1(TreeNode root) {
+        List<List<Integer>> list = new ArrayList<>();
+        Deque<TreeNode> que = new LinkedList<>();
+
+        if (root == null) {
+            return list;
+        }
+
+        que.offerLast(root);
+        while (!que.isEmpty()) {
+            List<Integer> levelList = new ArrayList<>();
+
+            int levelSize = que.size();
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode peek = que.peekFirst();
+                levelList.add(que.pollFirst().val);
+
+                if (peek.left != null) {
+                    que.offerLast(peek.left);
+                }
+                if (peek.right != null) {
+                    que.offerLast(peek.right);
+                }
+            }
+            list.add(levelList);
+        }
+
+        List<List<Integer>> result = new ArrayList<>();
+        for (int i = list.size() - 1; i >= 0; i-- ) {
+            result.add(list.get(i));
+        }
+
+        return result;
+    }
+}
+
+// 199.二叉树的右视图
+public class N0199 {
+    /**
+     * 解法：队列，迭代。
+     * 每次返回每层的最后一个字段即可。
+     *
+     * 小优化：每层右孩子先入队。代码略。
+     */
+    public List<Integer> rightSideView(TreeNode root) {
+        List<Integer> list = new ArrayList<>();
+        Deque<TreeNode> que = new LinkedList<>();
+
+        if (root == null) {
+            return list;
+        }
+
+        que.offerLast(root);
+        while (!que.isEmpty()) {
+            int levelSize = que.size();
+
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode poll = que.pollFirst();
+
+                if (poll.left != null) {
+                    que.addLast(poll.left);
+                }
+                if (poll.right != null) {
+                    que.addLast(poll.right);
+                }
+
+                if (i == levelSize - 1) {
+                    list.add(poll.val);
+                }
+            }
+        }
+
+        return list;
+    }
+}
+
+// 637. 二叉树的层平均值
+public class N0637 {
+
+    /**
+     * 解法：队列，迭代。
+     * 每次返回每层的最后一个字段即可。
+     */
+    public List<Double> averageOfLevels(TreeNode root) {
+        List<Double> list = new ArrayList<>();
+        Deque<TreeNode> que = new LinkedList<>();
+
+        if (root == null) {
+            return list;
+        }
+
+        que.offerLast(root);
+        while (!que.isEmpty()) {
+            TreeNode peek = que.peekFirst();
+
+            int levelSize = que.size();
+            double levelSum = 0.0;
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode poll = que.pollFirst();
+
+                levelSum += poll.val;
+
+                if (poll.left != null) {
+                    que.addLast(poll.left);
+                }
+                if (poll.right != null) {
+                    que.addLast(poll.right);
+                }
+            }
+            list.add(levelSum / levelSize);
+        }
+        return list;
+    }
+}
+
+// 429. N 叉树的层序遍历
+public class N0429 {
+    /**
+     * 解法1：队列，迭代。
+     */
+    public List<List<Integer>> levelOrder(Node root) {
+        List<List<Integer>> list = new ArrayList<>();
+        Deque<Node> que = new LinkedList<>();
+
+        if (root == null) {
+            return list;
+        }
+
+        que.offerLast(root);
+        while (!que.isEmpty()) {
+            int levelSize = que.size();
+            List<Integer> levelList = new ArrayList<>();
+
+            for (int i = 0; i < levelSize; i++) {
+                Node poll = que.pollFirst();
+
+                levelList.add(poll.val);
+
+                List<Node> children = poll.children;
+                if (children == null || children.size() == 0) {
+                    continue;
+                }
+                for (Node child : children) {
+                    if (child != null) {
+                        que.offerLast(child);
+                    }
+                }
+            }
+            list.add(levelList);
+        }
+
+        return list;
+    }
+
+    class Node {
+        public int val;
+        public List<Node> children;
+
+        public Node() {}
+
+        public Node(int _val) {
+            val = _val;
+        }
+
+        public Node(int _val, List<Node> _children) {
+            val = _val;
+            children = _children;
+        }
+    }
+}
 ```


@ -458,7 +660,6 @@ Go：



-
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
--- a/problems/0104.二叉树的最大深度.md
+++ b/problems/0104.二叉树的最大深度.md
@ -231,6 +231,18 @@ public:


 Java：
+```java
+class Solution {
+    public int maxDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        int leftdeep = maxDepth(root.left);
+        int rightdeep = maxDepth(root.right);
+        return 1+Math.max(leftdeep,rightdeep);
+    }
+}
+```


 Python：
@ -239,10 +251,16 @@ Python：
 Go：


-
+JavaScript
+```javascript
+var maxDepth = function(root) {
+    if (!root) return root
+    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right))
+};
+```

 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0106.从中序与后序遍历序列构造二叉树.md
+++ b/problems/0106.从中序与后序遍历序列构造二叉树.md
@ -582,6 +582,47 @@ tree2 的前序遍历是[1 2 3]， 后序遍历是[3 2 1]。


 Java：
+```java
+class Solution {
+    public TreeNode buildTree(int[] inorder, int[] postorder) {
+        if (inorder.length == 0 || postorder.length == 0) return null;
+        return buildTree(inorder, postorder,0,inorder.length,0,postorder.length);
+    }
+
+    private TreeNode buildTree(int[] inorder, int[] postorder, int infrom, int into,
+                                      int postfrom, int postto) {
+        if (postfrom == postto) return null;
+
+        int rootValue = postorder[postto - 1];
+        TreeNode root = new TreeNode(rootValue);
+
+        if (postfrom + 1 == postto) return root;
+
+        int splitNum = postto - 1;
+        for (int i = infrom; i < into; i++) {
+            if (inorder[i] == rootValue) {
+                splitNum = i;
+                break;
+            }
+        }
+
+        int inLeftBegin = infrom;
+        int inLeftEnd = splitNum;
+        int inRightBegin = splitNum + 1;
+        int inRightEnd = into;
+
+        int postLeftBegin = postfrom;
+        int postLeftEnd = postLeftBegin + (splitNum - inLeftBegin);
+        int postRightBegin = postLeftBegin + (splitNum - inLeftBegin);
+        int postRightEnd = postto - 1;
+
+        root.left = buildTree(inorder,postorder,inLeftBegin,inLeftEnd,postLeftBegin,postLeftEnd);
+        root.right = buildTree(inorder,postorder,inRightBegin,inRightEnd,postRightBegin,postRightEnd);
+
+        return root;
+    }
+}
+```


 Python：
@ -596,4 +637,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0108.将有序数组转换为二叉搜索树.md
+++ b/problems/0108.将有序数组转换为二叉搜索树.md
@ -209,6 +209,26 @@ public:


 Java：
+```java
+class Solution {
+    public TreeNode sortedArrayToBST(int[] nums) {
+        return sortArr(nums,0,nums.length);
+    }
+
+    private TreeNode sortArr(int[] nums, int lo, int hi) {
+        if (lo == hi) return null;
+        int rootIdx = (lo + hi)/2;
+
+        int rootValue = nums[rootIdx];
+        TreeNode root = new TreeNode(rootValue);
+
+        root.left = sortArr(nums,lo,rootIdx);
+        root.right = sortArr(nums,rootIdx+1,hi);
+
+        return root;
+    }
+}
+```


 Python：
@ -223,4 +243,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0110.平衡二叉树.md
+++ b/problems/0110.平衡二叉树.md
@ -353,15 +353,70 @@ public:

 ## 其他语言版本

-
 Java：
+```java
+class Solution {
+    boolean flag = true;
+    public boolean isBalanced(TreeNode root) {
+        high(root);
+        return flag;
+    }
+
+    private int high (TreeNode root) {
+        if (root == null) return 0;
+        if (flag) {
+            int left = high(root.left);
+            int right = high(root.right);
+
+            if (Math.abs(left - right) > 1) flag = false;
+
+            return Math.max(left,right) + 1;
+        } else {
+            return -1;
+        }
+    }
+}
+```


 Python：


 Go：
-
+```Go
+func isBalanced(root *TreeNode) bool {
+    if root==nil{
+        return true
+    }
+    if !isBalanced(root.Left) || !isBalanced(root.Right){
+        return false
+    }
+    LeftH:=maxdepth(root.Left)+1
+    RightH:=maxdepth(root.Right)+1
+    if abs(LeftH-RightH)>1{
+        return false
+    }
+    return true
+}
+func maxdepth(root *TreeNode)int{
+    if root==nil{
+        return 0
+    }
+    return max(maxdepth(root.Left),maxdepth(root.Right))+1
+}
+func max(a,b int)int{
+    if a>b{
+        return a
+    }
+    return b
+}
+func abs(a int)int{
+    if a<0{
+        return -a
+    }
+    return a 
+}
+```



@ -369,4 +424,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0111.二叉树的最小深度.md
+++ b/problems/0111.二叉树的最小深度.md
@ -194,10 +194,66 @@ public:


 Java：
+```java
+class Solution {
+    public int minDepth(TreeNode root) {
+        if (root == null) return 0;
+        int leftDeep = minDepth(root.left);
+        int rightDeep = minDepth(root.right);
+        
+        if (root.left == null && root.right != null) return 1+rightDeep;
+        if (root.left != null && root.right == null) return 1+leftDeep;

+        return Math.min(leftDeep,rightDeep)+1;
+    }
+}
+```

 Python：

+递归法：
+
+```python
+class Solution:
+    def minDepth(self, root: TreeNode) -> int:
+        if not root:
+            return 0
+        if not root.left and not root.right:
+            return 1
+
+        min_depth = 10**9
+        if root.left:
+            min_depth = min(self.minDepth(root.left), min_depth) # 获得左子树的最小高度
+        if root.right:
+            min_depth = min(self.minDepth(root.right), min_depth) # 获得右子树的最小高度
+        return min_depth + 1
+```
+
+迭代法：
+
+```python
+class Solution:
+    def minDepth(self, root: TreeNode) -> int:
+        if not root:
+            return 0
+        que = deque()
+        que.append(root)
+        res = 1
+
+        while que:
+            for _ in range(len(que)):
+                node = que.popleft()
+                # 当左右孩子都为空的时候，说明是最低点的一层了，退出
+                if not node.left and not node.right:
+                    return res
+                if node.left is not None:
+                    que.append(node.left)
+                if node.right is not None:
+                    que.append(node.right)
+            res += 1
+        return res
+```
+

 Go：

@ -208,4 +264,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@ -305,6 +305,24 @@ public:


 Java：
+```java
+class Solution {
+    private boolean flag = false;
+    public boolean hasPathSum(TreeNode root, int targetSum) {
+        has_2(root,targetSum);
+        return flag;
+    }
+
+    public void has_2 (TreeNode root, int count) {
+        if (root == null) return;
+        if (root.left == null && root.right == null && count == root.val) {
+            flag = true;
+        }
+        if (root.left != null) has_2(root.left,count - root.val);
+        if (root.right != null) has_2(root.right,count - root.val);
+    }
+}
+```


 Python：
@ -387,4 +405,4 @@ let pathSum = function (root, targetSum) {
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0122.买卖股票的最佳时机II.md
+++ b/problems/0122.买卖股票的最佳时机II.md
@ -135,10 +135,33 @@ public:


 Java：
-
+```java
+class Solution {
+    public int maxProfit(int[] prices) {
+        int sum = 0;
+        int profit = 0;
+        int buy = prices[0];
+        for (int i = 1; i < prices.length; i++) {
+            profit = prices[i] - buy;
+            if (profit > 0) {
+                sum += profit;
+            }
+            buy = prices[i];
+        }
+        return sum;
+    }
+}
+```

 Python：
-
+```python
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        result = 0
+        for i in range(1, len(prices)):
+            result += max(prices[i] - prices[i - 1], 0)
+        return result
+```

 Go：

@ -149,4 +172,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0131.分割回文串.md
+++ b/problems/0131.分割回文串.md
@ -250,7 +250,46 @@ public:


 Java：
+```Java
+class Solution {
+    List<List<String>> lists = new ArrayList<>();
+    Deque<String> deque = new LinkedList<>();

+    public List<List<String>> partition(String s) {
+        backTracking(s, 0);
+        return lists;
+    }
+
+    private void backTracking(String s, int startIndex) {
+        //如果起始位置大于s的大小，说明找到了一组分割方案
+        if (startIndex >= s.length()) {
+            lists.add(new ArrayList(deque));
+            return;
+        }
+        for (int i = startIndex; i < s.length(); i++) {
+            //如果是回文子串，则记录
+            if (isPalindrome(s, startIndex, i)) {
+                String str = s.substring(startIndex, i + 1);
+                deque.addLast(str);
+            } else {
+                continue;
+            }
+            //起始位置后移，保证不重复
+            backTracking(s, i + 1);
+            deque.removeLast();
+        }
+    }
+    //判断是否是回文串
+    private boolean isPalindrome(String s, int startIndex, int end) {
+        for (int i = startIndex, j = end; i < j; i++, j--) {
+            if (s.charAt(i) != s.charAt(j)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```

 Python：

--- a/problems/0134.加油站.md
+++ b/problems/0134.加油站.md
@ -199,7 +199,28 @@ public:


 Java：
+```java
+class Solution {
+    public int canCompleteCircuit(int[] gas, int[] cost) {
+        int sum = 0;
+        int min = 0;
+        for (int i = 0; i < gas.length; i++) {
+            sum += (gas[i] - cost[i]);
+            min = Math.min(sum, min);
+        }

+        if (sum < 0) return -1;
+        if (min >= 0) return 0;
+
+        for (int i = gas.length - 1; i > 0; i--) {
+            min += (gas[i] - cost[i]);
+            if (min >= 0) return i;
+        }
+
+        return -1;
+    }
+}
+```

 Python：

@ -213,4 +234,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0135.分发糖果.md
+++ b/problems/0135.分发糖果.md
@ -130,7 +130,35 @@ public:


 Java：
+```java
+class Solution {
+    public int candy(int[] ratings) {
+        int[] candy = new int[ratings.length];
+        for (int i = 0; i < candy.length; i++) {
+            candy[i] = 1;
+        }

+        for (int i = 1; i < ratings.length; i++) {
+            if (ratings[i] > ratings[i - 1]) {
+                candy[i] = candy[i - 1] + 1;
+            }
+        }
+
+        for (int i = ratings.length - 2; i >= 0; i--) {
+            if (ratings[i] > ratings[i + 1]) {
+                candy[i] = Math.max(candy[i],candy[i + 1] + 1);
+            }
+        }
+
+        int count = 0;
+        for (int i = 0; i < candy.length; i++) {
+            count += candy[i];
+        }
+
+        return count;
+    }
+}
+```

 Python：

@ -144,4 +172,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0139.单词拆分.md
+++ b/problems/0139.单词拆分.md
@ -232,7 +232,23 @@ public:


 Java：
+```java
+class Solution {
+    public boolean wordBreak(String s, List<String> wordDict) {
+        boolean[] valid = new boolean[s.length() + 1];
+        valid[0] = true;
+        for (int i = 1; i <= s.length(); i++) {
+            for (int j = 0; j < i; j++) {
+                if (wordDict.contains(s.substring(j,i)) && valid[j]) {
+                    valid[i] = true;
+                }
+            }
+        }

+        return valid[s.length()];
+    }
+}
+```

 Python：

@ -246,4 +262,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0142.环形链表II.md
+++ b/problems/0142.环形链表II.md
@ -186,6 +186,29 @@ public:


 Java：
+```java
+public class Solution {
+    public ListNode detectCycle(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+            if (slow == fast) {// 有环
+                ListNode index1 = fast;
+                ListNode index2 = head;
+                // 两个指针，从头结点和相遇结点，各走一步，直到相遇，相遇点即为环入口
+                while (index1 != index2) {
+                    index1 = index1.next;
+                    index2 = index2.next;
+                }
+                return index1;
+            }
+        }
+        return null;
+    }
+}
+```


 Python：
--- a/problems/0151.翻转字符串里的单词.md
+++ b/problems/0151.翻转字符串里的单词.md
@ -213,6 +213,74 @@ public:

 Java：

+```Java
+class Solution {
+   /**
+     * 不使用Java内置方法实现
+     * <p>
+     * 1.去除首尾以及中间多余空格
+     * 2.反转整个字符串
+     * 3.反转各个单词
+     */
+    public String reverseWords(String s) {
+        // System.out.println("ReverseWords.reverseWords2() called with: s = [" + s + "]");
+        // 1.去除首尾以及中间多余空格
+        StringBuilder sb = removeSpace(s);
+        // 2.反转整个字符串
+        reverseString(sb, 0, sb.length() - 1);
+        // 3.反转各个单词
+        reverseEachWord(sb);
+        return sb.toString();
+    }
+
+    private StringBuilder removeSpace(String s) {
+        // System.out.println("ReverseWords.removeSpace() called with: s = [" + s + "]");
+        int start = 0;
+        int end = s.length() - 1;
+        while (s.charAt(start) == ' ') start++;
+        while (s.charAt(end) == ' ') end--;
+        StringBuilder sb = new StringBuilder();
+        while (start <= end) {
+            char c = s.charAt(start);
+            if (c != ' ' || sb.charAt(sb.length() - 1) != ' ') {
+                sb.append(c);
+            }
+            start++;
+        }
+        // System.out.println("ReverseWords.removeSpace returned: sb = [" + sb + "]");
+        return sb;
+    }
+
+    /**
+     * 反转字符串指定区间[start, end]的字符
+     */
+    public void reverseString(StringBuilder sb, int start, int end) {
+        // System.out.println("ReverseWords.reverseString() called with: sb = [" + sb + "], start = [" + start + "], end = [" + end + "]");
+        while (start < end) {
+            char temp = sb.charAt(start);
+            sb.setCharAt(start, sb.charAt(end));
+            sb.setCharAt(end, temp);
+            start++;
+            end--;
+        }
+        // System.out.println("ReverseWords.reverseString returned: sb = [" + sb + "]");
+    }
+
+    private void reverseEachWord(StringBuilder sb) {
+        int start = 0;
+        int end = 1;
+        int n = sb.length();
+        while (start < n) {
+            while (end < n && sb.charAt(end) != ' ') {
+                end++;
+            }
+            reverseString(sb, start, end - 1);
+            start = end + 1;
+            end = start + 1;
+        }
+    }
+}
+```

 Python：

--- a/problems/0198.打家劫舍.md
+++ b/problems/0198.打家劫舍.md
@ -117,6 +117,33 @@ Python：


 Go：
+```Go
+func rob(nums []int) int {
+	if len(nums)<1{
+		return 0
+	}
+	if len(nums)==1{
+		return nums[0]
+	}
+	if len(nums)==2{
+		return max(nums[0],nums[1])
+	}
+	dp :=make([]int,len(nums))
+	dp[0]=nums[0]
+	dp[1]=max(nums[0],nums[1])
+	for i:=2;i<len(nums);i++{
+		dp[i]=max(dp[i-2]+nums[i],dp[i-1])
+	}
+	return dp[len(dp)-1]
+}
+
+func max(a, b int) int {
+	if a>b{
+		return a
+	}
+	return b
+}
+```



--- a/problems/0202.快乐数.md
+++ b/problems/0202.快乐数.md
@ -84,7 +84,28 @@ public:


 Java：
+```java
+class Solution {
+    public boolean isHappy(int n) {
+        Set<Integer> record = new HashSet<>();
+        while (n != 1 && !record.contains(n)) {
+            record.add(n);
+            n = getNextNumber(n);
+        }
+        return n == 1;
+    }

+    private int getNextNumber(int n) {
+        int res = 0;
+        while (n > 0) {
+            int temp = n % 10;
+            res += temp * temp;
+            n = n / 10;
+        }
+        return res;
+    }
+}
+```

 Python：

--- a/problems/0203.移除链表元素.md
+++ b/problems/0203.移除链表元素.md
@ -138,7 +138,63 @@ public:


 Java：
-
+```java
+/**
+ * 添加虚节点方式
+ * 时间复杂度 O(n)
+ * 空间复杂度 O(1)
+ * @param head
+ * @param val
+ * @return
+ */
+public ListNode removeElements(ListNode head, int val) {
+    if (head == null) {
+        return head;
+    }
+    // 因为删除可能涉及到头节点，所以设置dummy节点，统一操作
+    ListNode dummy = new ListNode(-1, head);
+    ListNode pre = dummy;
+    ListNode cur = head;
+    while (cur != null) {
+        if (cur.val == val) {
+            pre.next = cur.next;
+        } else {
+            pre = cur;
+        }
+        cur = cur.next;
+    }
+    return dummy.next;
+}
+/**
+ * 不添加虚拟节点方式
+ * 时间复杂度 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;
+    }
+    // 已经为null，提前退出
+    if (head == null) {
+        return head;
+    }
+    // 已确定当前head.val != val
+    ListNode pre = head;
+    ListNode cur = head.next;
+    while (cur != null) {
+        if (cur.val == val) {
+            pre.next = cur.next;
+        } else {
+            pre = cur;
+        }
+        cur = cur.next;
+    }
+    return head;
+}
+```

 Python：

--- a/problems/0206.翻转链表.md
+++ b/problems/0206.翻转链表.md
@ -102,7 +102,45 @@ public:


 Java：
+```java
+// 双指针
+class Solution {
+    public ListNode reverseList(ListNode head) {
+        ListNode prev = null;
+        ListNode cur = head;
+        ListNode temp = null;
+        while (cur != null) {
+            temp = cur.next;// 保存下一个节点
+            cur.next = prev;
+            prev = cur;
+            cur = temp;
+        }
+        return prev;
+    }
+}
+```

+```java
+// 递归 
+class Solution {
+    public ListNode reverseList(ListNode head) {
+        return reverse(null, head);
+    }
+
+    private ListNode reverse(ListNode prev, ListNode cur) {
+        if (cur == null) {
+            return prev;
+        }
+        ListNode temp = null;
+        temp = cur.next;// 先保存下一个节点
+        cur.next = prev;// 反转
+        // 更新prev、cur位置
+        prev = cur;
+        cur = temp;
+        return reverse(prev, cur);
+    }
+}
+```

 Python：

@ -116,4 +154,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0209.长度最小的子数组.md
+++ b/problems/0209.长度最小的子数组.md
@ -148,7 +148,25 @@ class Solution:


 Java：
+```java
+class Solution {

+    // 滑动窗口
+    public int minSubArrayLen(int s, int[] nums) {
+        int left = 0;
+        int sum = 0;
+        int result = Integer.MAX_VALUE;
+        for (int right = 0; right < nums.length; right++) {
+            sum += nums[right];
+            while (sum >= s) {
+                result = Math.min(result, right - left + 1);
+                sum -= nums[left++];
+            }
+        }
+        return result == Integer.MAX_VALUE ? 0 : result;
+    }
+}
+```

 Python：

@ -177,4 +195,4 @@ var minSubArrayLen = (target, nums) => {
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0216.组合总和III.md
+++ b/problems/0216.组合总和III.md
@ -227,7 +227,39 @@ public:


 Java：
+```java
+class Solution {
+    List<List<Integer>> res = new ArrayList<>();
+    List<Integer> list = new ArrayList<>();

+    public List<List<Integer>> combinationSum3(int k, int n) {
+        res.clear();
+        list.clear();
+        backtracking(k, n, 9);
+        return res;
+    }
+
+    private void backtracking(int k, int n, int maxNum) {
+        if (k == 0 && n == 0) {
+            res.add(new ArrayList<>(list));
+            return;
+        }
+
+        // 因为不能重复，并且单个数字最大值是maxNum，所以sum最大值为
+        // （maxNum + (maxNum - 1) + ... + (maxNum - k + 1)） == k * maxNum - k*(k - 1) / 2
+        if (maxNum == 0
+                || n > k * maxNum - k * (k - 1) / 2
+                || n < (1 + k) * k / 2) {
+            return;
+        }
+        list.add(maxNum);
+        backtracking(k - 1, n - maxNum, maxNum - 1);
+        list.remove(list.size() - 1);
+        backtracking(k, n, maxNum - 1);
+    }
+
+}
+```

 Python：

@ -241,4 +273,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0222.完全二叉树的节点个数.md
+++ b/problems/0222.完全二叉树的节点个数.md
@ -194,7 +194,18 @@ public:


 Java：
+```java
+class Solution {
+    public int countNodes(TreeNode root) {
+        if (root == null) return 0;

+        int leftnum = countNodes(root.left);
+        int rightnum = countNodes(root.right);
+
+        return leftnum + rightnum + 1;
+    }
+}
+```

 Python：

@ -208,4 +219,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0225.用队列实现栈.md
+++ b/problems/0225.用队列实现栈.md
@ -154,9 +154,58 @@ public:

 ## 其他语言版本

-
 Java：

+```java
+class MyStack {
+
+    Queue<Integer> queue1; // 和栈中保持一样元素的队列
+    Queue<Integer> queue2; // 辅助队列
+
+    /** Initialize your data structure here. */
+    public MyStack() {
+        queue1 = new LinkedList<>();
+        queue2 = new LinkedList<>();
+    }
+    
+    /** Push element x onto stack. */
+    public void push(int x) {
+        queue2.offer(x); // 先放在辅助队列中
+        while (!queue1.isEmpty()){
+            queue2.offer(queue1.poll());
+        }
+        Queue<Integer> queueTemp;
+        queueTemp = queue1;
+        queue1 = queue2;
+        queue2 = queueTemp; // 最后交换queue1和queue2，将元素都放到queue1中
+    }
+    
+    /** Removes the element on top of the stack and returns that element. */
+    public int pop() {
+        return queue1.poll(); // 因为queue1中的元素和栈中的保持一致，所以这个和下面两个的操作只看queue1即可
+    }
+    
+    /** Get the top element. */
+    public int top() {
+        return queue1.peek();
+    }
+    
+    /** Returns whether the stack is empty. */
+    public boolean empty() {
+        return queue1.isEmpty();
+    }
+}
+
+/**
+ * Your MyQueue object will be instantiated and called as such:
+ * MyQueue obj = new MyQueue();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.peek();
+ * boolean param_4 = obj.empty();
+ */
+```
+

 Python：

@ -227,4 +276,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0226.翻转二叉树.md
+++ b/problems/0226.翻转二叉树.md
@ -203,11 +203,29 @@ public:


 Java：
+```java
+class Solution {
+    public TreeNode invertTree(TreeNode root) {
+        invert(root);
+        return root;
+    }

+    private static void invert (TreeNode root) {
+        if (root == null) return;
+
+        invert(root.left);
+        TreeNode t = root.left;
+        root.left = root.right;
+        root.right = t;
+        
+        invert(root.left);
+    }
+}
+```

 Python：

-
+Go：
 ```Go
 func invertTree(root *TreeNode) *TreeNode {
    if root ==nil{
@ -230,4 +248,4 @@ func invertTree(root *TreeNode) *TreeNode {
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0232.用栈实现队列.md
+++ b/problems/0232.用栈实现队列.md
@ -19,7 +19,7 @@ push(x) -- 将一个元素放入队列的尾部。
 pop() -- 从队列首部移除元素。
 peek() -- 返回队列首部的元素。
 empty() -- 返回队列是否为空。
- 
+

 示例:

@ -129,9 +129,62 @@ public:

 ## 其他语言版本

-
 Java：

+```java
+class MyQueue {
+
+    Stack<Integer> stack1;
+    Stack<Integer> stack2;
+
+    /** Initialize your data structure here. */
+    public MyQueue() {
+        stack1 = new Stack<>(); // 负责进栈
+        stack2 = new Stack<>(); // 负责出栈
+    }
+    
+    /** Push element x to the back of queue. */
+    public void push(int x) {
+        stack1.push(x);
+    }
+    
+    /** Removes the element from in front of queue and returns that element. */
+    public int pop() {    
+        dumpStack1();
+        return stack2.pop();
+    }
+    
+    /** Get the front element. */
+    public int peek() {
+        dumpStack1();
+        return stack2.peek();
+    }
+    
+    /** Returns whether the queue is empty. */
+    public boolean empty() {
+        return stack1.isEmpty() && stack2.isEmpty();
+    }
+
+    // 如果stack2为空，那么将stack1中的元素全部放到stack2中
+    private void dumpStack1(){
+        if (stack2.isEmpty()){
+            while (!stack1.isEmpty()){
+                stack2.push(stack1.pop());
+            }
+        }
+    }
+}
+
+/**
+ * Your MyQueue object will be instantiated and called as such:
+ * MyQueue obj = new MyQueue();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.peek();
+ * boolean param_4 = obj.empty();
+ */
+```
+

 Python：

@ -145,4 +198,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0235.二叉搜索树的最近公共祖先.md
+++ b/problems/0235.二叉搜索树的最近公共祖先.md
@ -29,7 +29,7 @@
 输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
 输出: 2
 解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。
- 
+

 说明:

@ -229,7 +229,22 @@ public:


 Java：
-
+```java
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        while (true) {
+            if (root.val > p.val && root.val > q.val) {
+                root = root.left;
+            } else if (root.val < p.val && root.val < q.val) {
+                root = root.right;
+            } else {
+                break;
+            }
+        }
+        return root;
+    }
+}
+```

 Python：

@ -243,4 +258,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0236.二叉树的最近公共祖先.md
+++ b/problems/0236.二叉树的最近公共祖先.md
@ -223,7 +223,20 @@ public:


 Java：
-
+```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);
+        TreeNode right = lowestCommonAncestor(root.right,p,q);
+        if (left != null && right != null) return root;
+        else if (left == null && right != null) return right;
+        else if (left != null && right == null) return left;
+        else return null;
+    }
+}
+```

 Python：

@ -237,4 +250,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0239.滑动窗口最大值.md
+++ b/problems/0239.滑动窗口最大值.md
@ -207,7 +207,60 @@ public:


 Java：
+```Java
+//自定义数组
+class MyQueue {
+    Deque<Integer> deque = new LinkedList<>();
+    //弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出
+    //同时判断队列当前是否为空
+    void poll(int val) {
+        if (!deque.isEmpty() && val == deque.peek()) {
+            deque.poll();
+        }
+    }
+    //添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出
+    //保证队列元素单调递减
+    //比如此时队列元素3,1，2将要入队，比1大，所以1弹出，此时队列：3,2
+    void add(int val) {
+        while (!deque.isEmpty() && val > deque.getLast()) {
+            deque.removeLast();
+        }
+        deque.add(val);
+    }
+    //队列队顶元素始终为最大值
+    int peek() {
+        return deque.peek();
+    }
+}

+class Solution {
+    public int[] maxSlidingWindow(int[] nums, int k) {
+        if (nums.length == 1) {
+            return nums;
+        }
+        int len = nums.length - k + 1;
+        //存放结果元素的数组
+        int[] res = new int[len];
+        int num = 0;
+        //自定义队列
+        MyQueue myQueue = new MyQueue();
+        //先将前k的元素放入队列
+        for (int i = 0; i < k; i++) {
+            myQueue.add(nums[i]);
+        }
+        res[num++] = myQueue.peek();
+        for (int i = k; i < nums.length; i++) {
+            //滑动窗口移除最前面的元素，移除是判断该元素是否放入队列
+            myQueue.poll(nums[i - k]);
+            //滑动窗口加入最后面的元素
+            myQueue.add(nums[i]);
+            //记录对应的最大值
+            res[num++] = myQueue.peek();
+        }
+        return res;
+    }
+}
+```

 Python：

--- a/problems/0242.有效的字母异位词.md
+++ b/problems/0242.有效的字母异位词.md
@ -85,7 +85,26 @@ public:


 Java：
+```java
+class Solution {
+    public boolean isAnagram(String s, String t) {

+        int[] record = new int[26];
+        for (char c : s.toCharArray()) {
+            record[c - 'a'] += 1;
+        }
+        for (char c : t.toCharArray()) {
+            record[c - 'a'] -= 1;
+        }
+        for (int i : record) {
+            if (i != 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```

 Python：

@ -120,4 +139,4 @@ func isAnagram(s string, t string) bool {
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0257.二叉树的所有路径.md
+++ b/problems/0257.二叉树的所有路径.md
@ -280,8 +280,39 @@ public:

 ## 其他语言版本

-
 Java：
+```java
+class Solution {
+    public List<String> binaryTreePaths(TreeNode root) {
+        LinkedList<TreeNode> stack = new LinkedList<>();
+        List<String> list = new LinkedList<>();
+        TreePaths(root,stack,list);
+        return list;
+    }
+
+    private static void TreePaths (TreeNode root, LinkedList<TreeNode> path, List<String> res) {
+        path.add(root);
+        if (root.left == null && root.right == null) {
+            StringBuilder sb = new StringBuilder();
+            for (TreeNode n : path) {
+                sb.append(n.val);
+                sb.append("->");
+            }
+            sb.delete(sb.length()-2,sb.length());
+            res.add(sb.toString());
+            return;
+        }
+        if (root.left != null) {
+            TreePaths(root.left, path, res);
+            path.removeLast();
+        }
+        if (root.right != null) {
+            TreePaths(root.right, path, res);
+            path.removeLast();
+        }
+    }
+}
+```


 Python：
@ -296,4 +327,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0279.完全平方数.md
+++ b/problems/0279.完全平方数.md
@ -159,7 +159,28 @@ public:


 Java：
-
+```Java
+class Solution {
+    public int numSquares(int n) {
+        int max = Integer.MAX_VALUE;
+        int[] dp = new int[n + 1];
+        //初始化
+        for (int j = 0; j <= n; j++) {
+            dp[j] = max;
+        }
+        //当和为0时，组合的个数为0
+        dp[0] = 0;
+        for (int i = 1; i * i <= n; i++) {
+            for (int j = i * i; j <= n; j++) {
+                if (dp[j - i * i] != max) {
+                    dp[j] = Math.min(dp[j], dp[j - i * i] + 1);
+                }
+            }
+        }
+        return dp[n];
+    }
+}
+```

 Python：

--- a/problems/0322.零钱兑换.md
+++ b/problems/0322.零钱兑换.md
@ -181,7 +181,31 @@ public:


 Java：
-
+```Java
+class Solution {
+    public int coinChange(int[] coins, int amount) {
+        int max = Integer.MAX_VALUE;
+        int[] dp = new int[amount + 1];
+        //初始化dp数组为最大值
+        for (int j = 0; j < dp.length; j++) {
+            dp[j] = max;
+        }
+        //当金额为0时需要的硬币数目为0
+        dp[0] = 0;
+        for (int i = 0; i < coins.length; i++) {
+            //正序遍历：完全背包每个硬币可以选择多次
+            for (int j = coins[i]; j <= amount; j++) {
+                //只有dp[j-coins[i]]不是初始最大值时，该位才有选择的必要
+                if (dp[j - coins[i]] != max) {
+                    //选择硬币数目最小的情况
+                    dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
+                }
+            }
+        }
+        return dp[amount] == max ? -1 : dp[amount];
+    }
+}
+```

 Python：

--- a/problems/0344.反转字符串.md
+++ b/problems/0344.反转字符串.md
@ -140,12 +140,37 @@ public:


 Java：
-
+```Java
+class Solution {
+    public void reverseString(char[] s) {
+        int l = 0;
+        int r = s.length - 1;
+        while (l < r) {
+            s[l] ^= s[r];  //构造 a ^ b 的结果，并放在 a 中
+            s[r] ^= s[l];  //将 a ^ b 这一结果再 ^ b ，存入b中，此时 b = a, a = a ^ b
+            s[l] ^= s[r];  //a ^ b 的结果再 ^ a ，存入 a 中，此时 b = a, a = b 完成交换
+            l++;
+            r--;
+        }
+    }
+}
+```

 Python：


 Go：
+```Go
+func reverseString(s []byte)  {
+    left:=0
+    right:=len(s)-1
+    for left<right{
+        s[left],s[right]=s[right],s[left]
+        left++
+        right--
+    }
+}
+```



--- a/problems/0347.前K个高频元素.md
+++ b/problems/0347.前K个高频元素.md
@ -133,6 +133,32 @@ public:


 Java：
+```java
+
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+        int[] result = new int[k];
+        HashMap<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+
+        Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
+        // 根据map的value值正序排，相当于一个小顶堆
+        PriorityQueue<Map.Entry<Integer, Integer>> queue = new PriorityQueue<>((o1, o2) -> o1.getValue() - o2.getValue());
+        for (Map.Entry<Integer, Integer> entry : entries) {
+            queue.offer(entry);
+            if (queue.size() > k) {
+                queue.poll();
+            }
+        }
+        for (int i = k - 1; i >= 0; i--) {
+            result[i] = queue.poll().getKey();
+        }
+        return result;
+    }
+}
+```


 Python：
--- a/problems/0349.两个数组的交集.md
+++ b/problems/0349.两个数组的交集.md
@ -76,6 +76,37 @@ public:

 Java：

+```Java
+import java.util.HashSet;
+import java.util.Set;
+
+class Solution {
+    public int[] intersection(int[] nums1, int[] nums2) {
+        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
+            return new int[0];
+        }
+        Set<Integer> set1 = new HashSet<>();
+        Set<Integer> resSet = new HashSet<>();
+        //遍历数组1
+        for (int i : nums1) {
+            set1.add(i);
+        }
+        //遍历数组2的过程中判断哈希表中是否存在该元素
+        for (int i : nums2) {
+            if (set1.contains(i)) {
+                resSet.add(i);
+            }
+        }
+        int[] resArr = new int[resSet.size()];
+        int index = 0;
+        //将结果几何转为数组
+        for (int i : resSet) {
+            resArr[index++] = i;
+        }
+        return resArr;
+    }
+}
+```

 Python：

--- a/problems/0376.摆动序列.md
+++ b/problems/0376.摆动序列.md
@ -111,7 +111,31 @@ public:


 Java：
-
+```Java
+class Solution {
+    public int wiggleMaxLength(int[] nums) {
+        if (nums == null || nums.length <= 1) {
+            return nums.length;
+        }
+        //当前差值
+        int curDiff = 0;
+        //上一个差值
+        int preDiff = 0;
+        int count = 1;
+        for (int i = 1; i < nums.length; i++) {
+            //得到当前差值
+            curDiff = nums[i] - nums[i - 1];
+            //如果当前差值和上一个差值为一正一负
+            //等于0的情况表示初始时的preDiff
+            if ((curDiff > 0 && preDiff <= 0) || (curDiff < 0 && preDiff >= 0)) {
+                count++;
+                preDiff = curDiff;
+            }
+        }
+        return count;
+    }
+}
+```

 Python：

--- a/problems/0377.组合总和Ⅳ.md
+++ b/problems/0377.组合总和Ⅳ.md
@ -148,9 +148,39 @@ C++测试用例有超过两个树相加超过int的数据，所以需要在if里

 Java：

+```Java
+class Solution {
+    public int combinationSum4(int[] nums, int target) {
+        int[] dp = new int[target + 1];
+        dp[0] = 1;
+        for (int i = 0; i <= target; i++) {
+            for (int j = 0; j < nums.length; j++) {
+                if (i >= nums[j]) {
+                    dp[i] += dp[i - nums[j]];
+                }
+            }
+        }
+        return dp[target];
+    }
+}
+

 Python：

+```python
+class Solution:
+    def combinationSum4(self, nums, target):
+        dp = [0] * (target + 1)
+        dp[0] = 1
+
+        for i in range(1, target+1):
+            for j in nums:
+                if i >= j:
+                    dp[i] += dp[i - j]
+
+        return dp[-1]
+```
+

 Go：

@ -161,4 +191,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0383.赎金信.md
+++ b/problems/0383.赎金信.md
@ -111,7 +111,31 @@ public:


 Java：
+```Java
+class Solution {
+    public boolean canConstruct(String ransomNote, String magazine) {
+        //记录杂志字符串出现的次数
+        int[] arr = new int[26];
+        int temp;
+        for (int i = 0; i < magazine.length(); i++) {
+            temp = magazine.charAt(i) - 'a';
+            arr[temp]++;
+        }
+        for (int i = 0; i < ransomNote.length(); i++) {
+            temp = ransomNote.charAt(i) - 'a';
+            //对于金信中的每一个字符都在数组中查找
+            //找到相应位减一，否则找不到返回false
+            if (arr[temp] > 0) {
+                arr[temp]--;
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+}

+```

 Python：

--- a/problems/0404.左叶子之和.md
+++ b/problems/0404.左叶子之和.md
@ -159,9 +159,50 @@ public:

 ## 其他语言版本

-
 Java：

+**递归**
+
+```java
+class Solution {
+    public int sumOfLeftLeaves(TreeNode root) {
+        if (root == null) return 0;
+        int leftValue = sumOfLeftLeaves(root.left);    // 左
+        int rightValue = sumOfLeftLeaves(root.right);  // 右
+                                                       
+        int midValue = 0;
+        if (root.left != null && root.left.left == null && root.left.right == null) { // 中
+            midValue = root.left.val;
+        }
+        int sum = midValue + leftValue + rightValue;
+        return sum;
+    }
+}
+```
+
+**迭代**
+
+```java
+class Solution {
+    public int sumOfLeftLeaves(TreeNode root) {
+        if (root == null) return 0;
+        Stack<TreeNode> stack = new Stack<> ();
+        stack.add(root);
+        int result = 0;
+        while (!stack.isEmpty()) {
+            TreeNode node = stack.pop();
+            if (node.left != null && node.left.left == null && node.left.right == null) {
+                result += node.left.val;
+            }
+            if (node.right != null) stack.add(node.right);
+            if (node.left != null) stack.add(node.left);
+        }
+        return result;
+    }
+}
+```
+
+

 Python：

@ -175,4 +216,6 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
+
 <div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+
--- a/problems/0406.根据身高重建队列.md
+++ b/problems/0406.根据身高重建队列.md
@ -185,7 +185,30 @@ public:


 Java：
+```java
+class Solution {
+    public int[][] reconstructQueue(int[][] people) {
+        Arrays.sort(people, new Comparator<int[]>() {
+            @Override
+            public int compare(int[] o1, int[] o2) {
+                if (o1[0] != o2[0]) {
+                    return Integer.compare(o2[0],o1[0]);
+                } else {
+                    return Integer.compare(o1[1],o2[1]);
+                }
+            }
+        });

+        LinkedList<int[]> que = new LinkedList<>();
+
+        for (int[] p : people) {
+            que.add(p[1],p);
+        }
+
+        return que.toArray(new int[people.length][]);
+    }
+}
+```

 Python：

@ -199,4 +222,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0416.分割等和子集.md
+++ b/problems/0416.分割等和子集.md
@ -185,7 +185,41 @@ public:


 Java：
+```Java
+class Solution {
+    public boolean canPartition(int[] nums) {
+        int sum = 0;
+        for (int i : nums) {
+            sum += i;
+        }
+        if ((sum & 1) == 1) {
+            return false;
+        }
+        int length = nums.length;
+        int target = sum >> 1;
+        //dp[j]表示前i个元素可以找到相加等于j情况
+        boolean[] dp = new boolean[target + 1];
+        //对于第一个元素，只有当j=nums[0]时，才恰好填充满
+        if (nums[0] <= target) {
+            dp[nums[0]] = true;
+        }

+        for (int i = 1; i < length; i++) {
+            //j由右往左直到nums[i]
+            for (int j = target; j >= nums[i]; j--) {
+                //只有两种情况，要么放，要么不放
+                //取其中的TRUE值
+                dp[j] = dp[j] || dp[j - nums[i]];
+            }
+            //一旦满足，结束，因为只需要找到一组值即可
+            if (dp[target]) {
+                return dp[target];
+            }
+        }
+        return dp[target];
+    }
+}
+```

 Python：

--- a/problems/0435.无重叠区间.md
+++ b/problems/0435.无重叠区间.md
@ -182,7 +182,34 @@ public:


 Java：
+```java
+class Solution {
+    public int eraseOverlapIntervals(int[][] intervals) {
+        if (intervals.length < 2) return 0;
+        Arrays.sort(intervals, new Comparator<int[]>() {
+            @Override
+            public int compare(int[] o1, int[] o2) {
+                if (o1[0] != o2[0]) {
+                    return Integer.compare(o1[1],o2[1]);
+                } else {
+                    return Integer.compare(o2[0],o1[0]);
+                }
+            }
+        });

+        int count = 0;
+        int edge = intervals[0][1];
+        for (int i = 1; i < intervals.length; i++) {
+            if (intervals[i][0] < edge) {
+                count++;
+            } else {
+                edge = intervals[i][1];
+            }
+        }
+        return count;
+    }
+}
+```

 Python：

@ -196,4 +223,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0450.删除二叉搜索树中的节点.md
+++ b/problems/0450.删除二叉搜索树中的节点.md
@ -251,12 +251,77 @@ public:


 Java：
+```java
+class Solution {
+    public TreeNode deleteNode(TreeNode root, int key) {
+        root = delete(root,key);
+        return root;
+    }

+    private TreeNode delete(TreeNode root, int key) {
+        if (root == null) return null;
+
+        if (root.val > key) {
+            root.left = delete(root.left,key);
+        } else if (root.val < key) {
+            root.right = delete(root.right,key);
+        } else {
+            if (root.left == null) return root.right;
+            if (root.right == null) return root.left;
+            TreeNode tmp = root.right;
+            while (tmp.left != null) {
+                tmp = tmp.left;
+            }
+            root.val = tmp.val;
+            root.right = delete(root.right,tmp.val);
+        }
+        return root;
+    }
+}
+```

 Python：


 Go：
+```Go
+func deleteNode(root *TreeNode, key int) *TreeNode {
+    if root==nil{
+        return nil
+    }
+    if key<root.Val{
+        root.Left=deleteNode(root.Left,key)
+        return root
+    }
+    if key>root.Val{
+        root.Right=deleteNode(root.Right,key)
+        return root
+    }
+    if root.Right==nil{
+        return root.Left
+    }
+    if root.Left==nil{
+        return root.Right
+    }
+    minnode:=root.Right
+    for minnode.Left!=nil{
+        minnode=minnode.Left
+    }
+    root.Val=minnode.Val
+    root.Right=deleteNode1(root.Right)
+    return root
+}
+
+func deleteNode1(root *TreeNode)*TreeNode{
+    if root.Left==nil{
+        pRight:=root.Right
+        root.Right=nil
+        return pRight
+    }
+    root.Left=deleteNode1(root.Left)
+    return root
+}
+```



@ -265,4 +330,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0452.用最少数量的箭引爆气球.md
+++ b/problems/0452.用最少数量的箭引爆气球.md
@ -139,7 +139,32 @@ public:


 Java：
+```java
+class Solution {
+    public int findMinArrowShots(int[][] points) {
+        Arrays.sort(points, new Comparator<int[]>() {
+            @Override
+            public int compare(int[] o1, int[] o2) {
+                if (o1[0] != o2[0]) {
+                    return Integer.compare(o1[0],o2[0]);
+                } else {
+                    return Integer.compare(o1[0],o2[0]);
+                }
+            }
+        });

+        int count = 1;
+        for (int i = 1; i < points.length; i++) {
+            if (points[i][0] > points[i - 1][1]) {
+                count++;
+            } else {
+                points[i][1] = Math.min(points[i][1],points[i - 1][1]);
+            }
+        }
+        return count;
+    }
+}
+```

 Python：

@ -153,4 +178,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0454.四数相加II.md
+++ b/problems/0454.四数相加II.md
@ -88,7 +88,36 @@ public:


 Java：
-
+```Java
+class Solution {
+    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int temp;
+        int res = 0;
+        //统计两个数组中的元素之和，同时统计出现的次数，放入map
+        for (int i : nums1) {
+            for (int j : nums2) {
+                temp = i + j;
+                if (map.containsKey(temp)) {
+                    map.put(temp, map.get(temp) + 1);
+                } else {
+                    map.put(temp, 1);
+                }
+            }
+        }
+        //统计剩余的两个元素的和，在map中找是否存在相加为0的情况，同时记录次数
+        for (int i : nums3) {
+            for (int j : nums4) {
+                temp = i + j;
+                if (map.containsKey(0 - temp)) {
+                    res += map.get(0 - temp);
+                }
+            }
+        }
+        return res;
+    }
+}
+```

 Python：

--- a/problems/0455.分发饼干.md
+++ b/problems/0455.分发饼干.md
@ -30,7 +30,7 @@
 你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
 你拥有的饼干数量和尺寸都足以让所有孩子满足。
 所以你应该输出2.
- 
+

 提示：
 * 1 <= g.length <= 3 * 10^4
@ -115,7 +115,23 @@ public:


 Java：
-
+```java
+class Solution {
+    public int findContentChildren(int[] g, int[] s) {
+        Arrays.sort(g);
+        Arrays.sort(s);
+        int start = 0;
+        int count = 0;
+        for (int i = 0; i < s.length && start < g.length; i++) {
+            if (s[i] >= g[start]) {
+                start++;
+                count++;
+            }
+        }
+        return count;
+    }
+}
+```

 Python：

@ -129,4 +145,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0474.一和零.md
+++ b/problems/0474.一和零.md
@ -161,7 +161,33 @@ public:


 Java：
-
+```Java
+class Solution {
+    public int findMaxForm(String[] strs, int m, int n) {
+        //dp[i][j]表示i个0和j个1时的最大子集
+        int[][] dp = new int[m + 1][n + 1];
+        int oneNum, zeroNum;
+        for (String str : strs) {
+            oneNum = 0;
+            zeroNum = 0;
+            for (char ch : str.toCharArray()) {
+                if (ch == '0') {
+                    zeroNum++;
+                } else {
+                    oneNum++;
+                }
+            }
+            //倒序遍历
+            for (int i = m; i >= zeroNum; i--) {
+                for (int j = n; j >= oneNum; j--) {
+                    dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
+                }
+            }
+        }
+        return dp[m][n];
+    }
+}
+```

 Python：

--- a/problems/0491.递增子序列.md
+++ b/problems/0491.递增子序列.md
@ -200,6 +200,32 @@ public:


 Java：
+```java
+class Solution {
+    private List<Integer> path = new ArrayList<>();
+    private List<List<Integer>> res = new ArrayList<>();
+    public List<List<Integer>> findSubsequences(int[] nums) {
+        backtracking(nums,0);
+        return res;
+    }
+
+    private void backtracking (int[] nums, int start) {
+        if (path.size() > 1) {
+            res.add(new ArrayList<>(path));
+        }
+
+        int[] used = new int[201];
+        for (int i = start; i < nums.length; i++) {
+            if (!path.isEmpty() && nums[i] < path.get(path.size() - 1) ||
+                    (used[nums[i] + 100] == 1)) continue;
+            used[nums[i] + 100] = 1;
+            path.add(nums[i]);
+            backtracking(nums, i + 1);
+            path.remove(path.size() - 1);
+        }
+    }
+}
+```


 Python：
@ -214,4 +240,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0494.目标和.md
+++ b/problems/0494.目标和.md
@ -241,7 +241,24 @@ dp[j] += dp[j - nums[i]];


 Java：
-
+```java
+class Solution {
+    public int findTargetSumWays(int[] nums, int target) {
+        int sum = 0;
+        for (int i = 0; i < nums.length; i++) sum += nums[i];
+        if ((target + sum) % 2 != 0) return 0;
+        int size = (target + sum) / 2;
+        int[] dp = new int[size + 1];
+        dp[0] = 1;
+        for (int i = 0; i < nums.length; i++) {
+            for (int j = size; j >= nums[i]; j--) {
+                dp[j] += dp[j - nums[i]];
+            }
+        }
+        return dp[size];
+    }
+}
+```

 Python：

@ -255,4 +272,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0501.二叉搜索树中的众数.md
+++ b/problems/0501.二叉搜索树中的众数.md
@ -344,7 +344,47 @@ public:


 Java：
+```java
+class Solution {
+    private LinkedList<Integer> list = new LinkedList<>();
+    private int currentValue;
+    private int count;
+    private int maxCount;
+    public int[] findMode(TreeNode root) {
+        count = 0;
+        maxCount = 0;
+        currentValue = root.val;
+        findModeTrl(root);
+        int[] res = new int[list.size()];
+        for (int i = 0; i < res.length; i++) {
+            res[i] = list.get(i);
+        }
+        return res;
+    }

+    private void findModeTrl (TreeNode root) {
+        if (root == null) return;
+        findModeTrl(root.left);
+        if (root.val == currentValue) {
+            count++;
+        } else {
+            currentValue = root.val;
+            count = 1;
+        }
+
+        if (count == maxCount) {
+            list.add(root.val);
+        } else if (count > maxCount) {
+            maxCount = count;
+            list.clear();
+            list.add(currentValue);
+        }
+
+        findModeTrl(root.right);
+    }
+}
+
+```

 Python：

@ -358,4 +398,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0513.找树左下角的值.md
+++ b/problems/0513.找树左下角的值.md
@ -217,7 +217,29 @@ public:


 Java：
+```java
+class Solution {
+    private int Deep = -1;
+    private int value = 0;
+    public int findBottomLeftValue(TreeNode root) {
+        value = root.val;
+        findLeftValue(root,0);
+        return value;
+    }

+    private void findLeftValue (TreeNode root,int deep) {
+        if (root == null) return;
+        if (root.left == null && root.right == null) {
+            if (deep > Deep) {
+                value = root.val;
+                Deep = deep;
+            }
+        }
+        if (root.left != null) findLeftValue(root.left,deep + 1);
+        if (root.right != null) findLeftValue(root.right,deep + 1);
+    }
+}
+```

 Python：

@ -231,4 +253,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0516.最长回文子序列.md
+++ b/problems/0516.最长回文子序列.md
@ -148,6 +148,25 @@ public:


 Java：
+```java
+public class Solution {
+    public int longestPalindromeSubseq(String s) {
+        int len = s.length();
+        int[][] dp = new int[len + 1][len + 1];
+        for (int i = len - 1; i >= 0; i--) { // 从后往前遍历 保证情况不漏
+            dp[i][i] = 1; // 初始化
+            for (int j = i + 1; j < len; j++) {
+                if (s.charAt(i) == s.charAt(j)) {
+                    dp[i][j] = dp[i + 1][j - 1] + 2;
+                } else {
+                    dp[i][j] = Math.max(dp[i + 1][j], Math.max(dp[i][j], dp[i][j - 1]));
+                }
+            }
+        }
+        return dp[0][len - 1];
+    }
+}
+```


 Python：
--- a/problems/0518.零钱兑换II.md
+++ b/problems/0518.零钱兑换II.md
@ -188,7 +188,22 @@ public:


 Java：
-
+```Java
+class Solution {
+    public int change(int amount, int[] coins) {
+        //递推表达式
+        int[] dp = new int[amount + 1];
+        //初始化dp数组，表示金额为0时只有一种情况，也就是什么都不装
+        dp[0] = 1;
+        for (int i = 0; i < coins.length; i++) {
+            for (int j = coins[i]; j <= amount; j++) {
+                dp[j] += dp[j - coins[i]];
+            }
+        }
+        return dp[amount];
+    }
+}
+```

 Python：

--- a/problems/0530.二叉搜索树的最小绝对差.md
+++ b/problems/0530.二叉搜索树的最小绝对差.md
@ -151,7 +151,26 @@ public:


 Java：
+```java
+class Solution {
+    private TreeNode pre = null;
+    private int res = Integer.MAX_VALUE;
+    public int getMinimumDifference(TreeNode root) {
+        getMiniDiff(root);
+        return res;
+    }

+    private void getMiniDiff (TreeNode root) {
+        if (root == null) return;
+        getMiniDiff(root.left);
+        if (pre != null) {
+            res = Math.min(root.val - pre.val,res);
+        }
+        pre = root;
+        getMiniDiff(root.right);
+    }
+}
+```

 Python：

@ -165,4 +184,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0538.把二叉搜索树转换为累加树.md
+++ b/problems/0538.把二叉搜索树转换为累加树.md
@ -173,7 +173,23 @@ public:


 Java：
+```java
+class Solution {
+    private int count = 0;
+    public TreeNode convertBST(TreeNode root) {
+        convert(root);
+        return root;
+    }

+    private void convert (TreeNode root) {
+        if (root == null) return;
+        convert(root.right);
+        count += root.val;
+        root.val = count;
+        convert(root.left);
+    }
+}
+```

 Python：

@ -187,4 +203,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0541.反转字符串II.md
+++ b/problems/0541.反转字符串II.md
@ -46,7 +46,7 @@ https://leetcode-cn.com/problems/reverse-string-ii/

 使用C++库函数reverse的版本如下：

-```
+```C++
 class Solution {
 public:
    string reverseStr(string s, int k) {
@ -68,7 +68,8 @@ public:
 那么我们也可以实现自己的reverse函数，其实和题目[344. 反转字符串](https://mp.weixin.qq.com/s/X02S61WCYiCEhaik6VUpFA)道理是一样的。

 下面我实现的reverse函数区间是左闭右闭区间，代码如下：
-```
+
+```C++
 class Solution {
 public:
    void reverse(string& s, int start, int end) {
@ -101,7 +102,36 @@ public:


 Java：
+```Java
+class Solution {
+    public String reverseStr(String s, int k) {
+        StringBuffer res = new StringBuffer();

+        for (int i = 0; i < s.length(); i += (2 * k)) {
+            StringBuffer temp = new StringBuffer();
+            // 剩余字符大于 k 个，每隔 2k 个字符的前 k 个字符进行反转
+            if (i + k <= s.length()) {
+                // 反转前 k 个字符
+                temp.append(s.substring(i, i + k));
+                res.append(temp.reverse());
+
+                // 反转完前 k 个字符之后，如果紧接着还有 k 个字符，则直接加入这 k 个字符
+                if (i + 2 * k <= s.length()) {
+                    res.append(s.substring(i + k, i + 2 * k));
+                // 不足 k 个字符，则直接加入剩下所有字符
+                } else {
+                    res.append(s.substring(i + k, s.length()));
+                }
+                continue;
+            }
+            // 剩余字符少于 k 个，则将剩余字符全部反转。
+            temp.append(s.substring(i, s.length()));
+            res.append(temp.reverse());
+        }
+        return res.toString();
+    }
+}
+```

 Python：

--- a/problems/0617.合并二叉树.md
+++ b/problems/0617.合并二叉树.md
@ -256,7 +256,19 @@ public:


 Java：
+```java
+class Solution {
+    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
+        if (root1 == null) return root2;
+        if (root2 == null) return root1;

+        TreeNode newRoot = new TreeNode(root1.val + root2.val);
+        newRoot.left = mergeTrees(root1.left,root2.left);
+        newRoot.right = mergeTrees(root1.right,root2.right);
+        return newRoot;
+    }
+}
+```

 Python：

@ -270,4 +282,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0654.最大二叉树.md
+++ b/problems/0654.最大二叉树.md
@ -224,7 +224,31 @@ root->right = traversal(nums, maxValueIndex + 1, right);


 Java：
+```java
+class Solution {
+    public TreeNode constructMaximumBinaryTree(int[] nums) {
+        if (nums.length == 0) return null;
+        return constructMaximumBinaryTree(nums,0,nums.length);
+    }

+    private TreeNode constructMaximumBinaryTree(int[] nums, int begin, int end) {
+        if (begin == end) return null;
+
+        int rootValue = nums[begin];
+        int index = begin;
+        for (int i = begin; i < end ; i++) {
+            if (nums[i] > rootValue) {
+                rootValue = nums[i];
+                index = i;
+            }
+        }
+        TreeNode root = new TreeNode(rootValue);
+        root.left = constructMaximumBinaryTree(nums, begin,index);
+        root.right = constructMaximumBinaryTree(nums,index+1,end);
+        return root;
+    }
+}
+```

 Python：

@ -238,4 +262,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0669.修剪二叉搜索树.md
+++ b/problems/0669.修剪二叉搜索树.md
@ -242,7 +242,30 @@ public:


 Java：
+```java
+class Solution {
+    public TreeNode trimBST(TreeNode root, int low, int high) {
+        root = trim(root,low,high);
+        return root;
+    }

+    private static TreeNode trim(TreeNode root,int low, int high) {
+        if (root == null ) return null;
+        if (root.val < low) {
+            return trim(root.right,low,high);
+        }
+        if (root.val > high) {
+            return trim(root.left,low,high);
+        }
+
+        root.left = trim(root.left,low,high);
+        root.right = trim(root.right,low,high);
+
+        return root;
+    }
+}
+
+```

 Python：

@ -256,4 +279,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0700.二叉搜索树中的搜索.md
+++ b/problems/0700.二叉搜索树中的搜索.md
@ -140,12 +140,61 @@ public:

 ## 其他语言版本

-
 Java：
+递归法：


+```java
+class Solution {
+    public TreeNode searchBST(TreeNode root, int val) {
+        if (root == null) return null;
+        if (root.val == val) return root;
+        else if (root.val > val) return searchBST(root.left, val);
+        else return searchBST(root.right, val);
+    }
+}
+```
+
+迭代法：
+
+```java
+class Solution {
+    public TreeNode searchBST(TreeNode root, int val) {
+        while (root != null)
+            if (val < root.val) root = root.left;
+            else if (val > root.val) root = root.right;
+            else return root;
+        return root;
+    }
+}
+```
+
 Python：

+递归法：
+
+```python
+class Solution:
+    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
+        if root is None:
+            return None
+        if val < root.val: return self.searchBST(root.left, val)
+        elif val > root.val: return self.searchBST(root.right, val)
+        else: return root
+```
+
+迭代法：
+
+```python
+class Solution:
+    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
+        while root is not None:
+            if val < root.val: root = root.left
+            elif val > root.val: root = root.right
+            else: return root
+        return root
+```
+

 Go：

@ -156,4 +205,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0701.二叉搜索树中的插入操作.md
+++ b/problems/0701.二叉搜索树中的插入操作.md
@ -16,7 +16,7 @@
 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回任意有效的结果。

 ![701.二叉搜索树中的插入操作](https://img-blog.csdnimg.cn/20201019173259554.png)
- 
+
 提示：

 * 给定的树上的节点数介于 0 和 10^4 之间
@ -206,12 +206,69 @@ public:

 ## 其他语言版本

-
 Java：
+```java
+class Solution {
+    public TreeNode insertIntoBST(TreeNode root, int val) {
+        if (root == null) return new TreeNode(val);
+        TreeNode newRoot = root;
+        TreeNode pre = root;
+        while (root != null) {
+            pre = root;
+            if (root.val > val) {
+                root = root.left;
+            } else if (root.val < val) {
+                root = root.right;
+            } 
+        }
+        if (pre.val > val) {
+            pre.left = new TreeNode(val);
+        } else {
+            pre.right = new TreeNode(val);
+        }

+        return newRoot;
+    }
+}
+```
+
+递归法
+
+```java
+class Solution {
+    public TreeNode insertIntoBST(TreeNode root, int val) {
+        return buildTree(root, val);
+    }
+
+    public TreeNode buildTree(TreeNode root, int val){
+        if (root == null) // 如果当前节点为空，也就意味着val找到了合适的位置，此时创建节点直接返回。
+            return new TreeNode(val);
+        if (root.val < val){
+            root.right = buildTree(root.right, val); // 递归创建右子树
+        }else if (root.val > val){
+            root.left = buildTree(root.left, val); // 递归创建左子树
+        }
+        return root;
+    }
+}
+```

 Python：

+递归法
+
+```python
+class Solution:
+    def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
+        if root is None:
+            return TreeNode(val) # 如果当前节点为空，也就意味着val找到了合适的位置，此时创建节点直接返回。
+        if root.val < val:
+            root.right = self.insertIntoBST(root.right, val) # 递归创建右子树
+        if root.val > val:
+            root.left = self.insertIntoBST(root.left, val) # 递归创建左子树
+        return root
+```
+

 Go：

@ -222,4 +279,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0704.二分查找.md
+++ b/problems/0704.二分查找.md
@ -23,7 +23,7 @@
 输入: nums = [-1,0,3,5,9,12], target = 2
 输出: -1
 解释: 2 不存在 nums 中因此返回 -1
- 
+
 提示：

 * 你可以假设 nums 中的所有元素是不重复的。
@ -146,11 +146,50 @@ public:

 ## 其他语言版本

-
 Java：

+（版本一）左闭右闭区间
+
+```java
+class Solution {
+    public int search(int[] nums, int target) {
+        int left = 0, right = nums.length - 1;
+        while (left <= right) {
+            int mid = left + ((right - left) >> 1);
+            if (nums[mid] == target)
+                return mid;
+            else if (nums[mid] < target)
+                left = mid + 1;
+            else if (nums[mid] > target)
+                right = mid - 1;
+        }
+        return -1;
+    }
+}
+```
+
+（版本二）左闭右开区间
+
+```java
+class Solution {
+    public int search(int[] nums, int target) {
+        int left = 0, right = nums.length;
+        while (left < right) {
+            int mid = left + ((right - left) >> 1);
+            if (nums[mid] == target)
+                return mid;
+            else if (nums[mid] < target)
+                left = mid + 1;
+            else if (nums[mid] > target)
+                right = mid;
+        }
+        return -1;
+    }
+}
+```

 Python：
+
 ```python3
 class Solution:
    def search(self, nums: List[int], target: int) -> int:
@ -178,4 +217,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0707.设计链表.md
+++ b/problems/0707.设计链表.md
@ -157,7 +157,78 @@ private:


 Java：
+```Java
+class MyLinkedList {
+    //size存储链表元素的个数
+    int size;
+    //虚拟头结点
+    ListNode head;

+    //初始化链表
+    public MyLinkedList() {
+        size = 0;
+        head = new ListNode(0);
+    }
+
+    //获取第index个节点的数值
+    public int get(int index) {
+        //如果index非法，返回-1
+        if (index < 0 || index >= size) {
+            return -1;
+        }
+        ListNode currentNode = head;
+        //包含一个虚拟头节点，所以查找第 index+1 个节点
+        for (int i = 0; i <= index; i++) {
+            currentNode = currentNode.next;
+        }
+        return currentNode.val;
+    }
+
+    //在链表最前面插入一个节点
+    public void addAtHead(int val) {
+        addAtIndex(0, val);
+    }
+
+    //在链表的最后插入一个节点
+    public void addAtTail(int val) {
+        addAtIndex(size, val);
+    }
+
+    // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
+    // 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
+    // 如果 index 大于链表的长度，则返回空
+    public void addAtIndex(int index, int val) {
+        if (index > size) {
+            return;
+        }
+        if (index < 0) {
+            index = 0;
+        }
+        size++;
+        //找到要插入节点的前驱
+        ListNode pred = head;
+        for (int i = 0; i < index; i++) {
+            pred = pred.next;
+        }
+        ListNode toAdd = new ListNode(val);
+        toAdd.next = pred.next;
+        pred.next = toAdd;
+    }
+
+    //删除第index个节点
+    public void deleteAtIndex(int index) {
+        if (index < 0 || index >= size) {
+            return;
+        }
+        size--;
+        ListNode pred = head;
+        for (int i = 0; i < index; i++) {
+            pred = pred.next;
+        }
+        pred.next = pred.next.next;
+    }
+}
+```

 Python：

--- a/problems/0714.买卖股票的最佳时机含手续费.md
+++ b/problems/0714.买卖股票的最佳时机含手续费.md
@ -156,7 +156,23 @@ public:


 Java：
-
+```java
+class Solution {
+    public int maxProfit(int[] prices, int fee) {
+        int buy = prices[0] + fee;
+        int sum = 0;
+        for (int p : prices) {
+            if (p + fee < buy) {
+                buy = p + fee;
+            } else if (p > buy){
+                sum += p - buy;
+                buy = p;
+            }
+        }
+        return sum;
+    }
+}
+```

 Python：

--- a/problems/0738.单调递增的数字.md
+++ b/problems/0738.单调递增的数字.md
@ -125,6 +125,24 @@ public:


 Java：
+```java
+class Solution {
+    public int monotoneIncreasingDigits(int N) {
+        String[] strings = (N + "").split("");
+        int start = strings.length;
+        for (int i = strings.length - 1; i > 0; i--) {
+            if (Integer.parseInt(strings[i]) < Integer.parseInt(strings[i - 1])) {
+                strings[i - 1] = (Integer.parseInt(strings[i - 1]) - 1) + "";
+                start = i;
+            }
+        }
+        for (int i = start; i < strings.length; i++) {
+            strings[i] = "9";
+        }
+        return Integer.parseInt(String.join("",strings));
+    }
+}
+```


 Python：
@ -139,4 +157,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0746.使用最小花费爬楼梯.md
+++ b/problems/0746.使用最小花费爬楼梯.md
@ -203,7 +203,26 @@ public:


 Java：
-
+```Java
+class Solution {
+    public int minCostClimbingStairs(int[] cost) {
+        if (cost == null || cost.length == 0) {
+            return 0;
+        }
+        if (cost.length == 1) {
+            return cost[0];
+        }
+        int[] dp = new int[cost.length];
+        dp[0] = cost[0];
+        dp[1] = cost[1];
+        for (int i = 2; i < cost.length; i++) {
+            dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        //最后一步，如果是由倒数第二步爬，则最后一步的体力花费可以不用算
+        return Math.min(dp[cost.length - 1], dp[cost.length - 2]);
+    }
+}
+```

 Python：

--- a/problems/0763.划分字母区间.md
+++ b/problems/0763.划分字母区间.md
@ -84,7 +84,28 @@ public:


 Java：
-
+```java
+class Solution {
+    public List<Integer> partitionLabels(String S) {
+        List<Integer> list = new LinkedList<>();
+        int[] edge = new int[123];
+        char[] chars = S.toCharArray();
+        for (int i = 0; i < chars.length; i++) {
+            edge[chars[i] - 0] = i;
+        }
+        int idx = 0;
+        int last = -1;
+        for (int i = 0; i < chars.length; i++) {
+            idx = Math.max(idx,edge[chars[i] - 0]);
+            if (i == idx) {
+                list.add(i - last);
+                last = i;
+            }
+        }
+        return list;
+    }
+}
+```

 Python：

--- a/problems/0860.柠檬水找零.md
+++ b/problems/0860.柠檬水找零.md
@ -127,7 +127,33 @@ public:


 Java：
+```java
+class Solution {
+    public boolean lemonadeChange(int[] bills) {
+        int cash_5 = 0;
+        int cash_10 = 0;

+        for (int i = 0; i < bills.length; i++) {
+            if (bills[i] == 5) {
+                cash_5++;
+            } else if (bills[i] == 10) {
+                cash_5--;
+                cash_10++;
+            } else if (bills[i] == 20) {
+                if (cash_10 > 0) {
+                    cash_10--;
+                    cash_5--;
+                } else {
+                    cash_5 -= 3;
+                }
+            }
+            if (cash_5 < 0 || cash_10 < 0) return false;
+        }
+        
+        return true;
+    }
+}
+```

 Python：

@ -141,4 +167,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/0968.监控二叉树.md
+++ b/problems/0968.监控二叉树.md
@ -316,6 +316,33 @@ public:


 Java：
+```java
+class Solution {
+    private int count = 0;
+    public int minCameraCover(TreeNode root) {
+        if (trval(root) == 0) count++;
+        return count;
+    }
+
+    private int trval(TreeNode root) {
+        if (root == null) return -1;
+
+        int left = trval(root.left);
+        int right = trval(root.right);
+
+        if (left == 0 || right == 0) {
+            count++;
+            return 2;
+        }
+
+        if (left == 2 || right == 2) {
+            return 1;
+        }
+
+        return 0;
+    }
+}
+```


 Python：
@ -330,4 +357,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/1005.K次取反后最大化的数组和.md
+++ b/problems/1005.K次取反后最大化的数组和.md
@ -29,7 +29,7 @@
 输入：A = [2,-3,-1,5,-4], K = 2
 输出：13
 解释：选择索引 (1, 4) ，然后 A 变为 [2,3,-1,5,4]。
- 
+
 提示：

 * 1 <= A.length <= 10000
@ -99,7 +99,29 @@ public:


 Java：
+```java
+class Solution {
+    public int largestSumAfterKNegations(int[] A, int K) {
+        if (A.length == 1) return A[0];
+        Arrays.sort(A);
+        int sum = 0;
+        int idx = 0;
+        for (int i = 0; i < K; i++) {
+            if (i < A.length - 1 && A[idx] < 0) {
+                A[idx] = -A[idx];
+                if (A[idx] >= Math.abs(A[idx + 1])) idx++;
+                continue;
+            }
+            A[idx] = -A[idx];
+        }

+        for (int i = 0; i < A.length; i++) {
+            sum += A[i];
+        }
+        return sum;
+    }
+}
+```

 Python：

@ -113,4 +135,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/1047.删除字符串中的所有相邻重复项.md
+++ b/problems/1047.删除字符串中的所有相邻重复项.md
@ -122,7 +122,28 @@ public:


 Java：
-
+```Java
+class Solution {
+    public String removeDuplicates(String S) {
+        Deque<Character> deque = new LinkedList<>();
+        char ch;
+        for (int i = 0; i < S.length(); i++) {
+            ch = S.charAt(i);
+            if (deque.isEmpty() || deque.peek() != ch) {
+                deque.push(ch);
+            } else {
+                deque.pop();
+            }
+        }
+        String str = "";
+        //剩余的元素即为不重复的元素
+        while (!deque.isEmpty()) {
+            str = deque.pop() + str;
+        }
+        return str;
+    }
+}
+```

 Python：

--- a/problems/1143.最长公共子序列.md
+++ b/problems/1143.最长公共子序列.md
@ -31,7 +31,7 @@
 输入：text1 = "abc", text2 = "def"      
 输出：0        
 解释：两个字符串没有公共子序列，返回 0。    
- 
+
 提示:       
 * 1 <= text1.length <= 1000
 * 1 <= text2.length <= 1000
@ -126,12 +126,44 @@ public:

 ## 其他语言版本

-
 Java：

+```java
+class Solution {
+    public int longestCommonSubsequence(String text1, String text2) {
+        int[][] dp = new int[text1.length() + 1][text2.length() + 1]; // 先对dp数组做初始化操作
+        for (int i = 1 ; i <= text1.length() ; i++) {
+            char char1 = text1.charAt(i - 1);
+            for (int j = 1; j <= text2.length(); j++) {
+                char char2 = text2.charAt(j - 1);
+                if (char1 == char2) { // 开始列出状态转移方程
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                } else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                }
+            }
+        }
+        return dp[text1.length()][text2.length()];
+    }
+}
+```

 Python：

+```python
+class Solution:
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        len1, len2 = len(text1)+1, len(text2)+1
+        dp = [[0 for _ in range(len1)] for _ in range(len2)] # 先对dp数组做初始化操作
+        for i in range(1, len2):
+            for j in range(1, len1): # 开始列出状态转移方程
+                if text1[j-1] == text2[i-1]:
+                    dp[i][j] = dp[i-1][j-1]+1 
+                else:
+                    dp[i][j] = max(dp[i-1][j], dp[i][j-1])
+        return dp[-1][-1]
+```
+

 Go：

@ -142,4 +174,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
--- a/problems/剑指Offer05.替换空格.md
+++ b/problems/剑指Offer05.替换空格.md
@ -129,7 +129,26 @@ for (int i = 0; i < a.size(); i++) {


 Java：
-
+```Java
+//使用一个新的对象，复制 str，复制的过程对其判断，是空格则替换，否则直接复制，类似于数组复制
+public static String replaceSpace(StringBuffer str) {
+        if (str == null) {
+            return null;
+        }
+		//选用 StringBuilder 单线程使用，比较快，选不选都行
+        StringBuilder sb = new StringBuilder();
+		//使用 sb 逐个复制 str ，碰到空格则替换，否则直接复制
+        for (int i = 0; i < str.length(); i++) {
+		//str.charAt(i) 为 char 类型，为了比较需要将其转为和 " " 相同的字符串类型
+            if (" ".equals(String.valueOf(str.charAt(i)))){
+                sb.append("%20");
+            } else {
+                sb.append(str.charAt(i));
+            }
+        }
+        return sb.toString();
+    }
+```

 Python：

--- a/problems/回溯算法理论基础.md
+++ b/problems/回溯算法理论基础.md
@ -163,10 +163,6 @@ void backtracking(参数) {



-![](https://img-blog.csdnimg.cn/20210416110157800.png)
-
-
-
 ## 其他语言版本


--- a/problems/数组总结篇.md
+++ b/problems/数组总结篇.md
@ -131,9 +131,6 @@
 最后，大家周末愉快！


-
-
-
 ## 其他语言版本


--- a/problems/数组理论基础.md
+++ b/problems/数组理论基础.md
@ -7,6 +7,7 @@
 <p align="center"><strong>欢迎大家参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>


+
 ## 数组理论基础

 数组是非常基础的数据结构，在面试中，考察数组的题目一般在思维上都不难，主要是考察对代码的掌控能力
@ -23,6 +24,8 @@

 ![算法通关数组](https://code-thinking.cdn.bcebos.com/pics/%E7%AE%97%E6%B3%95%E9%80%9A%E5%85%B3%E6%95%B0%E7%BB%84.png)

+
+
 需要两点注意的是

 * **数组下标都是从0开始的。**
@ -34,6 +37,7 @@

 ![算法通关数组1](https://code-thinking.cdn.bcebos.com/pics/%E7%AE%97%E6%B3%95%E9%80%9A%E5%85%B3%E6%95%B0%E7%BB%841.png)

+
 而且大家如果使用C++的话，要注意vector 和 array的区别，vector的底层实现是array，严格来讲vector是容器，不是数组。

 **数组的元素是不能删的，只能覆盖。**
@ -42,110 +46,80 @@

 ![算法通关数组2](https://code-thinking.cdn.bcebos.com/pics/%E7%AE%97%E6%B3%95%E9%80%9A%E5%85%B3%E6%95%B0%E7%BB%842.png)

+
 **那么二维数组在内存的空间地址是连续的么？**

-不同编程语言的内存管理是不一样的，以C++为例，在C++中二维数组是连续分布的，如图：
+不同编程语言的内存管理是不一样的，以C++为例，在C++中二维数组是连续分布的。
+
+我们来做一个实验，C++测试代码如下：
+
+```C++
+void test_arr() {
+    int array[2][3] = {
+		{0, 1, 2},
+		{3, 4, 5}
+    };
+    cout << &array[0][0] << " " << &array[0][1] << " " << &array[0][2] << endl;
+    cout << &array[1][0] << " " << &array[1][1] << " " << &array[1][2] << endl;
+}
+
+int main() {
+    test_arr();
+}
+
+```
+
+测试地址为
+
+```
+0x7ffee4065820 0x7ffee4065824 0x7ffee4065828
+0x7ffee406582c 0x7ffee4065830 0x7ffee4065834
+```
+
+注意地址为16进制，可以看出二维数组地址是连续一条线的。
+
+一些录友可能看不懂内存地址，我就简单介绍一下， 0x7ffee4065820 与 0x7ffee4065824 差了一个4，就是4个字节，因为这是一个int型的数组，所以两个相信数组元素地址差4个字节。
+
+0x7ffee4065828 与 0x7ffee406582c 也是差了4个字节，在16进制里8 + 4 = c，c就是12。
+
+如图：

 ![数组内存](https://img-blog.csdnimg.cn/20210310150641186.png)

-Java的二维数组可能是如下排列的方式：
+**所以可以看出在C++中二维数组在地址空间上是连续的**。
+
+像Java是没有指针的，同时也不对程序员暴漏其元素的地址，寻址操作完全交给虚拟机。
+
+所以看不到每个元素的地址情况，这里我以Java为例，也做一个实验。
+
+```Java
+public static void test_arr() {
+    int[][] arr = {{1, 2, 3}, {3, 4, 5}, {6, 7, 8}, {9,9,9}};
+    System.out.println(arr[0]);
+    System.out.println(arr[1]);
+    System.out.println(arr[2]);
+    System.out.println(arr[3]);
+}
+```
+输出的地址为：
+
+```
+[I@7852e922
+[I@4e25154f
+[I@70dea4e
+[I@5c647e05
+```
+
+这里的数值也是16进制，这不是真正的地址，而是经过处理过后的数值了，我们也可以看出，二维数组的每一行头结点的地址是没有规则的，更谈不上连续。
+
+所以Java的二维数组可能是如下排列的方式：

 ![算法通关数组3](https://img-blog.csdnimg.cn/20201214111631844.png)

-我们在[数组过于简单，但你该了解这些！](https://mp.weixin.qq.com/s/c2KABb-Qgg66HrGf8z-8Og)分别作了实验
+这里面试中数组相关的理论知识就介绍完了。

-## 数组的经典题目
+后续我将介绍面试中数组相关的五道经典面试题目，敬请期待！

-在面试中，数组是必考的基础数据结构。
-
-其实数据的题目在思想上一般比较简单的，但是如果想高效，并不容易。
-
-我们之前一共讲解了四道经典数组题目，每一道题目都代表一个类型，一种思想。
-
-### 二分法
-
-[704.二分查找](https://mp.weixin.qq.com/s/4X-8VRgnYRGd5LYGZ33m4w)
-
-在这道题目中我们讲到了**循环不变量原则**，只有在循环中坚持对区间的定义，才能清楚的把握循环中的各种细节。
-
-**二分法是算法面试中的常考题，建议通过这道题目，锻炼自己手撕二分的能力**。
-
-相关题目：
-
-* 35.搜索插入位置
-* 34.在排序数组中查找元素的第一个和最后一个位置
-* 69.x 的平方根
-* 367.有效的完全平方数
-
-### 双指针法
-
-[27. 移除元素](https://mp.weixin.qq.com/s/RMkulE4NIb6XsSX83ra-Ww)
-
-双指针法（快慢指针法）：**通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。**
-
-暴力解法时间复杂度：O(n^2)
-双指针时间复杂度：O(n)
-
-这道题目迷惑了不少同学，纠结于数组中的元素为什么不能删除，主要是因为一下两点：
-
-* 数组在内存中是连续的地址空间，不能释放单一元素，如果要释放，就是全释放（程序运行结束，回收内存栈空间）。
-* C++中vector和array的区别一定要弄清楚，vector的底层实现是array，所以vector展现出友好的一些都是因为经过包装了。
-
-双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组和链表操作的面试题，都使用双指针法。
-
-相关题目：
-
-* 26.删除排序数组中的重复项
-* 283.移动零
-* 844.比较含退格的字符串
-* 977.有序数组的平方
-
-### 滑动窗口
-
-[209.长度最小的子数组](https://mp.weixin.qq.com/s/ewCRwVw0h0v4uJacYO7htQ)
-
-本题介绍了数组操作中的另一个重要思想：滑动窗口。
-
-暴力解法时间复杂度：O(n^2)
-滑动窗口时间复杂度：O(n)
-
-本题中，主要要理解滑动窗口如何移动 窗口起始位置，达到动态更新窗口大小的，从而得出长度最小的符合条件的长度。
-
-**滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)的暴力解法降为O(n)。**
-
-如果没有接触过这一类的方法，很难想到类似的解题思路，滑动窗口方法还是很巧妙的。
-
-相关题目：
-
-* 904.水果成篮
-* 76.最小覆盖子串
-
-### 模拟行为
-
-[59.螺旋矩阵II](https://mp.weixin.qq.com/s/Hn6-mlCPvKAdWbiFfQyaaw)
-
-模拟类的题目在数组中很常见，不涉及到什么算法，就是单纯的模拟，十分考察大家对代码的掌控能力。
-
-在这道题目中，我们再一次介绍到了**循环不变量原则**，其实这也是写程序中的重要原则。
-
-相信大家又遇到过这种情况： 感觉题目的边界调节超多，一波接着一波的判断，找边界，踩了东墙补西墙，好不容易运行通过了，代码写的十分冗余，毫无章法，其实**真正解决题目的代码都是简洁的，或者有原则性的**，大家可以在这道题目中体会到这一点。
-
-相关题目：
-
-* 54.螺旋矩阵
-* 剑指Offer 29.顺时针打印矩阵
-
-## 总结
-
-从二分法到双指针，从滑动窗口到螺旋矩阵，相信如果大家真的认真做了「代码随想录」每日推荐的题目，定会有所收获。
-
-**每道题目后面都有相关练习题，也别忘了去做做！**
-
-数组专题中讲解和相关题目已经有16道了，就不介绍太过题目了，因为数组是非常基础的数据结构后面很多专题还会用到数组，所以后面的题目依然会会间接练习数组的。
-
-
-
-![](https://img-blog.csdnimg.cn/20210416110157800.png)

 ## 其他语言版本