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

2025-07-09 19:44:45 +08:00 · 2021-05-15 09:25:43 +08:00
parent ac9b03ae8e 0405daf6d9
commit 169c1a0a32
86 changed files with 3250 additions and 207 deletions
--- a/problems/0015.三数之和.md
+++ b/problems/0015.三数之和.md
@ -221,6 +221,40 @@ Python：


 Go：
+```Go
+func threeSum(nums []int)[][]int{
+	sort.Ints(nums)
+	res:=[][]int{}
+	
+	for i:=0;i<len(nums)-2;i++{
+		n1:=nums[i]
+		if n1>0{
+			break
+		}
+		if i>0&&n1==nums[i-1]{
+			continue
+		}
+		l,r:=i+1,len(nums)-1
+		for l<r{
+			n2,n3:=nums[l],nums[r]
+			if n1+n2+n3==0{
+				res=append(res,[]int{n1,n2,n3})
+				for l<r&&nums[l]==n2{
+					l++
+				}
+				for l<r&&nums[r]==n3{
+					r--
+				}
+			}else if n1+n2+n3<0{
+				l++
+			}else {
+				r--
+			}
+		}
+	}
+	return res
+}
+```



--- 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/0019.删除链表的倒数第N个节点.md
+++ b/problems/0019.删除链表的倒数第N个节点.md
@ -112,7 +112,28 @@ class Solution {
    }
 }
 ```
+Go:
+```Go
+func removeNthFromEnd(head *ListNode, n int) *ListNode {
+    result:=&ListNode{}
+    result.Next=head
+    var pre *ListNode
+    cur:=result

+    i:=1
+    for head!=nil{
+        if i>=n{
+            pre=cur
+            cur=cur.Next
+        }
+        head=head.Next
+        i++
+    }
+    pre.Next=pre.Next.Next
+    return result.Next
+
+}
+```

 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
--- 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
@ -14,7 +14,7 @@
 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。


-![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-%E9%A2%98%E6%84%8F.jpg)
+<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>

 ## 思路

--- 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/0053.最大子序和.md
+++ b/problems/0053.最大子序和.md
@ -139,14 +139,65 @@ 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
+func maxSubArray(nums []int) int {
+    if len(nums)<1{
+        return 0
+    }
+    dp:=make([]int,len(nums))
+    result:=nums[0]
+    dp[0]=nums[0]
+    for i:=1;i<len(nums);i++{
+        dp[i]=max(dp[i-1]+nums[i],nums[i])
+        result=max(dp[i],result)
+    }
+    return result
+}

-
+func max(a,b int)int{
+    if a>b{
+        return a
+    }else{
+        return b
+    }
+}
+```


 -----------------------
--- a/problems/0055.跳跃游戏.md
+++ b/problems/0055.跳跃游戏.md
@ -107,7 +107,19 @@ class Solution {
 ```

 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,12 +177,60 @@ 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:

--- a/problems/0090.子集II.md
+++ b/problems/0090.子集II.md
@ -172,12 +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]
+	}
+}
+```
+

 Javascript:

@ -211,7 +268,6 @@ var subsetsWithDup = function(nums) {



-
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
--- 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
@ -255,12 +255,80 @@ public:

 Java：

+```Java
+class Solution {
+    // 递归
+    TreeNode max;
+    public boolean isValidBST(TreeNode root) {
+        if (root == null) {
+            return true;
+        }
+        // 左
+        boolean left = isValidBST(root.left);
+        if (!left) {
+            return false;
+        }
+        // 中
+        if (max != null && root.val <= max.val) {
+            return false;
+        }
+        max = root;
+        // 右
+        boolean right = isValidBST(root.right);
+        return right;
+    }
+}
+
+class Solution {
+    // 迭代
+    public boolean isValidBST(TreeNode root) {
+        if (root == null) {
+            return true;
+        }
+        Stack<TreeNode> stack = new Stack<>();
+        TreeNode pre = null;
+        while (root != null || !stack.isEmpty()) {
+            while (root != null) {
+                stack.push(root);
+                root = root.left;// 左
+            }
+            // 中，处理
+            TreeNode pop = stack.pop();
+            if (pre != null && pop.val <= pre.val) {
+                return false;
+            }
+            pre = pop;
+
+            root = pop.right;// 右
+        }
+        return true;
+    }
+}
+```

 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 +336,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,110 @@ public:

 ## 其他语言版本

-
 Java：

+```Java
+    /**
+     * 递归法
+     */
+    public boolean isSymmetric1(TreeNode root) {
+        return compare(root.left, root.right);
+    }
+
+    private boolean compare(TreeNode left, TreeNode right) {
+
+        if (left == null && right != null) {
+            return false;
+        }
+        if (left != null && right == null) {
+            return false;
+        }
+
+        if (left == null && right == null) {
+            return true;
+        }
+        if (left.val != right.val) {
+            return false;
+        }
+        // 比较外侧
+        boolean compareOutside = compare(left.left, right.right);
+        // 比较内侧
+        boolean compareInside = compare(left.right, right.left);
+        return compareOutside && compareInside;
+    }
+
+    /**
+     * 迭代法
+     * 使用双端队列，相当于两个栈
+     */
+    public boolean isSymmetric2(TreeNode root) {
+        Deque<TreeNode> deque = new LinkedList<>();
+        deque.offerFirst(root.left);
+        deque.offerLast(root.right);
+        while (!deque.isEmpty()) {
+            TreeNode leftNode = deque.pollFirst();
+            TreeNode rightNode = deque.pollLast();
+            if (leftNode == null && rightNode == null) {
+                continue;
+            }
+//            if (leftNode == null && rightNode != null) {
+//                return false;
+//            }
+//            if (leftNode != null && rightNode == null) {
+//                return false;
+//            }
+//            if (leftNode.val != rightNode.val) {
+//                return false;
+//            }
+            // 以上三个判断条件合并
+            if (leftNode == null || rightNode == null || leftNode.val != rightNode.val) {
+                return false;
+            }
+            deque.offerFirst(leftNode.left);
+            deque.offerFirst(leftNode.right);
+            deque.offerLast(rightNode.right);
+            deque.offerLast(rightNode.left);
+        }
+        return true;
+    }
+
+    /**
+     * 迭代法
+     * 使用普通队列
+     */
+    public boolean isSymmetric3(TreeNode root) {
+        Queue<TreeNode> deque = new LinkedList<>();
+        deque.offer(root.left);
+        deque.offer(root.right);
+        while (!deque.isEmpty()) {
+            TreeNode leftNode = deque.poll();
+            TreeNode rightNode = deque.poll();
+            if (leftNode == null && rightNode == null) {
+                continue;
+            }
+//            if (leftNode == null && rightNode != null) {
+//                return false;
+//            }
+//            if (leftNode != null && rightNode == null) {
+//                return false;
+//            }
+//            if (leftNode.val != rightNode.val) {
+//                return false;
+//            }
+            // 以上三个判断条件合并
+            if (leftNode == null || rightNode == null || leftNode.val != rightNode.val) {
+                return false;
+            }
+            // 这里顺序与使用Deque不同
+            deque.offer(leftNode.left);
+            deque.offer(rightNode.right);
+            deque.offer(leftNode.right);
+            deque.offer(rightNode.left);
+        }
+        return true;
+    }
+
+```

 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
@ -232,6 +232,52 @@ public:

 Java：

+```Java
+class Solution {
+    /**
+     * 递归法
+     */
+    public int maxDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        int leftDepth = maxDepth(root.left);
+        int rightDepth = maxDepth(root.right);
+        return Math.max(leftDepth, rightDepth) + 1;
+
+    }
+}
+```
+
+```Java
+class Solution {
+    /**
+     * 迭代法，使用层序遍历
+     */
+    public int maxDepth(TreeNode root) {
+        if(root == null) {
+            return 0;
+        }
+        Deque<TreeNode> deque = new LinkedList<>();
+        deque.offer(root);
+        int depth = 0;
+        while (!deque.isEmpty()) {
+            int size = deque.size();
+            depth++;
+            for (int i = 0; i < size; i++) {
+                TreeNode poll = deque.poll();
+                if (poll.left != null) {
+                    deque.offer(poll.left);
+                }
+                if (poll.right != null) {
+                    deque.offer(poll.right);
+                }
+            }
+        }
+        return depth;
+    }
+}
+```

 Python：

@ -239,10 +285,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,7 +582,40 @@ tree2 的前序遍历是[1 2 3]， 后序遍历是[3 2 1]。


 Java：
-
+```java
+class Solution {
+    public TreeNode buildTree(int[] inorder, int[] postorder) {
+        return buildTree1(inorder, 0, inorder.length, postorder, 0, postorder.length);
+    }
+    public TreeNode buildTree1(int[] inorder, int inLeft, int inRight,
+                               int[] postorder, int postLeft, int postRight) {
+        // 没有元素了
+        if (inRight - inLeft < 1) {
+            return null;
+        }
+        // 只有一个元素了
+        if (inRight - inLeft == 1) {
+            return new TreeNode(inorder[inLeft]);
+        }
+        // 后序数组postorder里最后一个即为根结点
+        int rootVal = postorder[postRight - 1];
+        TreeNode root = new TreeNode(rootVal);
+        int rootIndex = 0;
+        // 根据根结点的值找到该值在中序数组inorder里的位置
+        for (int i = inLeft; i < inRight; i++) {
+            if (inorder[i] == rootVal) {
+                rootIndex = i;
+            }
+        }
+        // 根据rootIndex划分左右子树
+        root.left = buildTree1(inorder, inLeft, rootIndex,
+                postorder, postLeft, postLeft + (rootIndex - inLeft));
+        root.right = buildTree1(inorder, rootIndex + 1, inRight,
+                postorder, postLeft + (rootIndex - inLeft), postRight - 1);
+        return root;
+    }
+}
+```

 Python：

@ -596,4 +629,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,7 +209,28 @@ public:


 Java：
+```Java
+class Solution {
+    public TreeNode sortedArrayToBST(int[] nums) {
+        return sortedArrayToBST(nums, 0, nums.length);
+    }
+    
+    public TreeNode sortedArrayToBST(int[] nums, int left, int right) {
+        if (left >= right) {
+            return null;
+        }
+        if (right - left == 1) {
+            return new TreeNode(nums[left]);
+        }
+        int mid = left + (right - left) / 2;
+        TreeNode root = new TreeNode(nums[mid]);
+        root.left = sortedArrayToBST(nums, left, mid);
+        root.right = sortedArrayToBST(nums, mid + 1, right);
+        return root;
+    }
+}

+```

 Python：

@ -223,4 +244,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,187 @@ public:

 ## 其他语言版本

-
 Java：

+```Java
+class Solution {
+   /**
+     * 递归法
+     */
+    public boolean isBalanced(TreeNode root) {
+        return getHeight(root) != -1;
+    }
+
+    private int getHeight(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        int leftHeight = getHeight(root.left);
+        if (leftHeight == -1) {
+            return -1;
+        }
+        int rightHeight = getHeight(root.right);
+        if (rightHeight == -1) {
+            return -1;
+        }
+        // 左右子树高度差大于1，return -1表示已经不是平衡树了
+        if (Math.abs(leftHeight - rightHeight) > 1) {
+            return -1;
+        }
+        return Math.max(leftHeight, rightHeight) + 1;
+    }
+}
+
+class Solution {
+   /**
+     * 迭代法，效率较低，计算高度时会重复遍历
+     * 时间复杂度：O(n^2)
+     */
+    public boolean isBalanced(TreeNode root) {
+        if (root == null) {
+            return true;
+        }
+        Stack<TreeNode> stack = new Stack<>();
+        TreeNode pre = null;
+        while (root!= null || !stack.isEmpty()) {
+            while (root != null) {
+                stack.push(root);
+                root = root.left;
+            }
+            TreeNode inNode = stack.peek();
+            // 右结点为null或已经遍历过
+            if (inNode.right == null || inNode.right == pre) {
+                // 比较左右子树的高度差，输出
+                if (Math.abs(getHeight(inNode.left) - getHeight(inNode.right)) > 1) {
+                    return false;
+                }
+                stack.pop();
+                pre = inNode;
+                root = null;// 当前结点下，没有要遍历的结点了
+            } else {
+                root = inNode.right;// 右结点还没遍历，遍历右结点
+            }
+        }
+        return true;
+    }
+
+    /**
+     * 层序遍历，求结点的高度
+     */
+    public int getHeight(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        Deque<TreeNode> deque = new LinkedList<>();
+        deque.offer(root);
+        int depth = 0;
+        while (!deque.isEmpty()) {
+            int size = deque.size();
+            depth++;
+            for (int i = 0; i < size; i++) {
+                TreeNode poll = deque.poll();
+                if (poll.left != null) {
+                    deque.offer(poll.left);
+                }
+                if (poll.right != null) {
+                    deque.offer(poll.right);
+                }
+            }
+        }
+        return depth;
+    }
+}
+
+class Solution {
+   /**
+     * 优化迭代法，针对暴力迭代法的getHeight方法做优化，利用TreeNode.val来保存当前结点的高度，这样就不会有重复遍历
+     * 获取高度算法时间复杂度可以降到O(1)，总的时间复杂度降为O(n)。
+     * <p>
+     * 时间复杂度：O(n)
+     */
+    public boolean isBalanced(TreeNode root) {
+        if (root == null) {
+            return true;
+        }
+        Stack<TreeNode> stack = new Stack<>();
+        TreeNode pre = null;
+        while (root != null || !stack.isEmpty()) {
+            while (root != null) {
+                stack.push(root);
+                root = root.left;
+            }
+            TreeNode inNode = stack.peek();
+            // 右结点为null或已经遍历过
+            if (inNode.right == null || inNode.right == pre) {
+                // 输出
+                if (Math.abs(getHeight(inNode.left) - getHeight(inNode.right)) > 1) {
+                    return false;
+                }
+                stack.pop();
+                pre = inNode;
+                root = null;// 当前结点下，没有要遍历的结点了
+            } else {
+                root = inNode.right;// 右结点还没遍历，遍历右结点
+            }
+        }
+        return true;
+    }
+
+    /**
+     * 求结点的高度
+     */
+    public int getHeight(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        int leftHeight = root.left != null ? root.left.val : 0;
+        int rightHeight = root.right != null ? root.right.val : 0;
+        int height = Math.max(leftHeight, rightHeight) + 1;
+        root.val = height;// 用TreeNode.val来保存当前结点的高度
+        return height;
+    }
+}
+// LeetCode题解链接：https://leetcode-cn.com/problems/balanced-binary-tree/solution/110-ping-heng-er-cha-shu-di-gui-fa-bao-l-yqr3/
+```

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



--- a/problems/0111.二叉树的最小深度.md
+++ b/problems/0111.二叉树的最小深度.md
@ -195,9 +195,109 @@ public:

 Java：

+```Java
+class Solution {
+    /**
+     * 递归法，相比求MaxDepth要复杂点
+     * 因为最小深度是从根节点到最近**叶子节点**的最短路径上的节点数量
+     */
+    public int minDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        int leftDepth = minDepth(root.left);
+        int rightDepth = minDepth(root.right);
+        if (root.left == null) {
+            return rightDepth + 1;
+        }
+        if (root.right == null) {
+            return leftDepth + 1;
+        }
+        // 左右结点都不为null
+        return Math.min(leftDepth, rightDepth) + 1;
+    }
+}
+```
+
+```Java
+class Solution {
+   /**
+     * 迭代法，层序遍历
+     */
+    public int minDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        Deque<TreeNode> deque = new LinkedList<>();
+        deque.offer(root);
+        int depth = 0;
+        while (!deque.isEmpty()) {
+            int size = deque.size();
+            depth++;
+            for (int i = 0; i < size; i++) {
+                TreeNode poll = deque.poll();
+                if (poll.left == null && poll.right == null) {
+                    // 是叶子结点，直接返回depth，因为从上往下遍历，所以该值就是最小值
+                    return depth;
+                }
+                if (poll.left != null) {
+                    deque.offer(poll.left);
+                }
+                if (poll.right != null) {
+                    deque.offer(poll.right);
+                }
+            }
+        }
+        return depth;
+    }
+}
+```

 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：

--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@ -305,7 +305,34 @@ public:


 Java：
+```Java
+class Solution {
+   public boolean hasPathSum(TreeNode root, int targetSum) {
+        if (root == null) {
+            return false;
+        }
+        targetSum -= root.val;
+        // 叶子结点
+        if (root.left == null && root.right == null) {
+            return targetSum == 0;
+        }
+        if (root.left != null) {
+            boolean left = hasPathSum(root.left, targetSum);
+            if (left) {// 已经找到
+                return true;
+            }
+        }
+        if (root.right != null) {
+            boolean right = hasPathSum(root.right, targetSum);
+            if (right) {// 已经找到
+                return true;
+            }
+        }
+        return false;
+    }
+}

+```

 Python：

@ -387,4 +414,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/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,49 @@ public:


 Java：
+```java
+class Solution {
+    // 通用递归解法
+    public int countNodes(TreeNode root) {
+        if(root == null) {
+            return 0;
+        }
+        return countNodes(root.left) + countNodes(root.right) + 1;
+    }
+}
+```

+```java
+class Solution {
+    /**
+     * 针对完全二叉树的解法
+     *
+     * 满二叉树的结点数为：2^depth - 1
+     */
+    public int countNodes(TreeNode root) {
+        if(root == null) {
+            return 0;
+        }
+        int leftDepth = getDepth(root.left);
+        int rightDepth = getDepth(root.right);
+        if (leftDepth == rightDepth) {// 左子树是满二叉树
+            // 2^leftDepth其实是 （2^leftDepth - 1） + 1 ，左子树 + 根结点
+            return (1 << leftDepth) + countNodes(root.right);
+        } else {// 右子树是满二叉树
+            return (1 << rightDepth) + countNodes(root.left);
+        }
+    }
+
+    private int getDepth(TreeNode root) {
+        int depth = 0;
+        while (root != null) {
+            root = root.left;
+            depth++;
+        }
+        return depth;
+    }
+}
+```

 Python：

@ -208,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/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
@ -204,12 +204,48 @@ public:

 Java：

+```Java
+class Solution {
+   /**
+     * 前后序遍历都可以
+     * 中序不行，因为先左孩子交换孩子，再根交换孩子（做完后，右孩子已经变成了原来的左孩子），再右孩子交换孩子（此时其实是对原来的左孩子做交换）
+     */
+    public TreeNode invertTree(TreeNode root) {
+        if (root == null) {
+            return null;
+        }
+        invertTree(root.left);
+        invertTree(root.right);
+        swapChildren(root);
+        return root;
+    }
+
+    private void swapChildren(TreeNode root) {
+        TreeNode tmp = root.left;
+        root.left = root.right;
+        root.right = tmp;
+    }
+}
+```

 Python：

-
 Go：
+```Go
+func invertTree(root *TreeNode) *TreeNode {
+    if root ==nil{
+        return nil
+    }
+    temp:=root.Left
+    root.Left=root.Right
+    root.Right=temp
+    
+    invertTree(root.Left)
+    invertTree(root.Right)

+    return root
+}
+```



@ -217,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/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,8 +223,45 @@ public:


 Java：
+```Java
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        return lowestCommonAncestor1(root, p, q);
+    }
+    public TreeNode lowestCommonAncestor1(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == null || root == p || root == q) {
+            return root;
+        }
+        TreeNode left = lowestCommonAncestor1(root.left, p, q);
+        TreeNode right = lowestCommonAncestor1(root.right, p, q);
+        if (left != null && right != null) {// 左右子树分别找到了，说明此时的root就是要求的结果
+            return root;
+        }
+        if (left == null) {
+            return right;
+        }
+        return left;
+    }
+}
+```


+```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 +274,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,9 +280,48 @@ public:

 ## 其他语言版本

-
 Java：

+```Java
+class Solution {
+    /**
+     * 递归法
+     */
+    public List<String> binaryTreePaths(TreeNode root) {
+        List<String> res = new ArrayList<>();
+        if (root == null) {
+            return res;
+        }
+        List<Integer> paths = new ArrayList<>();
+        traversal(root, paths, res);
+        return res;
+    }
+
+    private void traversal(TreeNode root, List<Integer> paths, List<String> res) {
+        paths.add(root.val);
+        // 叶子结点
+        if (root.left == null && root.right == null) {
+            // 输出
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < paths.size() - 1; i++) {
+                sb.append(paths.get(i)).append("->");
+            }
+            sb.append(paths.get(paths.size() - 1));
+            res.add(sb.toString());
+            return;
+        }
+        if (root.left != null) {
+            traversal(root.left, paths, res);
+            paths.remove(paths.size() - 1);// 回溯
+        }
+        if (root.right != null) {
+            traversal(root.right, paths, res);
+            paths.remove(paths.size() - 1);// 回溯
+        }
+    }
+}
+
+```

 Python：

@ -296,4 +335,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/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
@ -147,6 +147,7 @@ C++测试用例有超过两个树相加超过int的数据，所以需要在if里


 Java：
+
 ```Java
 class Solution {
    public int combinationSum4(int[] nums, int target) {
@ -163,10 +164,23 @@ class Solution {
    }
 }

-```

 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：

@ -177,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/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/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/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/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：
@ -242,4 +268,4 @@ var findSubsequences = function(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/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
@ -345,6 +345,53 @@ public:

 Java：

+```Java
+class Solution {
+    ArrayList<Integer> resList;
+    int maxCount;
+    int count;
+    TreeNode pre;
+
+    public int[] findMode(TreeNode root) {
+        resList = new ArrayList<>();
+        maxCount = 0;
+        count = 0;
+        pre = null;
+        findMode1(root);
+        int[] res = new int[resList.size()];
+        for (int i = 0; i < resList.size(); i++) {
+            res[i] = resList.get(i);
+        }
+        return res;
+    }
+
+    public void findMode1(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        findMode1(root.left);
+
+        int rootValue = root.val;
+        // 计数
+        if (pre == null || rootValue != pre.val) {
+            count = 1;
+        } else {
+            count++;
+        }
+        // 更新结果以及maxCount
+        if (count > maxCount) {
+            resList.clear();
+            resList.add(rootValue);
+            maxCount = count;
+        } else if (count == maxCount) {
+            resList.add(rootValue);
+        }
+        pre = root;
+
+        findMode1(root.right);
+    }
+}
+```

 Python：

@ -358,4 +405,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
@ -218,6 +218,60 @@ 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);
+    }
+}
+```
+
+```java
+//迭代法
+class Solution {
+
+    public int findBottomLeftValue(TreeNode root) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+        int res = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            for (int i = 0; i < size; i++) {
+                TreeNode poll = queue.poll();
+                if (i == 0) {
+                    res = poll.val;
+                }
+                if (poll.left != null) {
+                    queue.offer(poll.left);
+                }
+                if (poll.right != null) {
+                    queue.offer(poll.right);
+                }
+            }
+        }
+        return res;
+    }
+}
+```
+
+

 Python：

@ -231,4 +285,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/0530.二叉搜索树的最小绝对差.md
+++ b/problems/0530.二叉搜索树的最小绝对差.md
@ -152,6 +152,29 @@ public:

 Java：

+```Java
+class Solution {
+    TreeNode pre;// 记录上一个遍历的结点
+    int result = Integer.MAX_VALUE;
+    public int getMinimumDifference(TreeNode root) {
+        if (root == null) {
+            return result;
+        }
+        // 左
+        int left = getMinimumDifference(root.left);
+        
+        // 中
+        if (pre != null) {
+            result = Math.min(left, root.val - pre.val);
+        }
+        pre = root;
+        // 右
+        int right = getMinimumDifference(root.right);
+        result = Math.min(right, result);
+        return result;
+    }
+}
+```

 Python：

@ -165,4 +188,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,27 @@ public:


 Java：
+```Java
+class Solution {
+    int sum;
+    public TreeNode convertBST(TreeNode root) {
+        sum = 0;
+        convertBST1(root);
+        return root;
+    }

+    // 按右中左顺序遍历，累加即可
+    public void convertBST1(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        convertBST1(root.right);
+        sum += root.val;
+        root.val = sum;
+        convertBST1(root.left);
+    }
+}
+```

 Python：

@ -187,4 +207,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
@ -257,6 +257,59 @@ 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;
+    }
+}
+```
+
+```Java
+class Solution {
+   // 迭代
+    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
+        if (root1 == null) {
+            return root2;
+        }
+        if (root2 == null) {
+            return root1;
+        }
+        Stack<TreeNode> stack = new Stack<>();
+        stack.push(root2);
+        stack.push(root1);
+        while (!stack.isEmpty()) {
+            TreeNode node1 = stack.pop();
+            TreeNode node2 = stack.pop();
+            node1.val += node2.val;
+            if (node2.right != null && node1.right != null) {
+                stack.push(node2.right);
+                stack.push(node1.right);
+            } else {
+                if (node1.right == null) {
+                    node1.right = node2.right;
+                }
+            }
+            if (node2.left != null && node1.left != null) {
+                stack.push(node2.left);
+                stack.push(node1.left);
+            } else {
+                if (node1.left == null) {
+                    node1.left = node2.left;
+                }
+            }
+        }
+        return root1;
+    }
+}
+```

 Python：

@ -270,4 +323,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
@ -225,6 +225,35 @@ root->right = traversal(nums, maxValueIndex + 1, right);

 Java：

+```Java
+class Solution {
+    public TreeNode constructMaximumBinaryTree(int[] nums) {
+        return constructMaximumBinaryTree1(nums, 0, nums.length);
+    }
+
+    public TreeNode constructMaximumBinaryTree1(int[] nums, int leftIndex, int rightIndex) {
+        if (rightIndex - leftIndex < 1) {// 没有元素了
+            return null;
+        }
+        if (rightIndex - leftIndex == 1) {// 只有一个元素
+            return new TreeNode(nums[leftIndex]);
+        }
+        int maxIndex = leftIndex;// 最大值所在位置
+        int maxVal = nums[maxIndex];// 最大值
+        for (int i = leftIndex + 1; i < rightIndex; i++) {
+            if (nums[i] > maxVal){
+                maxVal = nums[i];
+                maxIndex = i;
+            }
+        }
+        TreeNode root = new TreeNode(maxVal);
+        // 根据maxIndex划分左右子树
+        root.left = constructMaximumBinaryTree1(nums, leftIndex, maxIndex);
+        root.right = constructMaximumBinaryTree1(nums, maxIndex + 1, rightIndex);
+        return root;
+    }
+}
+```

 Python：

@ -238,4 +267,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
@ -243,6 +243,26 @@ public:

 Java：

+```Java
+class Solution {
+    public TreeNode trimBST(TreeNode root, int low, int high) {
+        if (root == null) {
+            return null;
+        }
+        if (root.val < low) {
+            return trimBST(root.right, low, high);
+        }
+        if (root.val > high) {
+            return trimBST(root.left, low, high);
+        }
+        // root在[low,high]范围内
+        root.left = trimBST(root.left, low, high);
+        root.right = trimBST(root.right, low, high);
+        return root;
+    }
+}
+
+```

 Python：

@ -256,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/0700.二叉搜索树中的搜索.md
+++ b/problems/0700.二叉搜索树中的搜索.md
@ -140,12 +140,99 @@ public:

 ## 其他语言版本

-
 Java：

+```Java
+class Solution {
+    // 递归，普通二叉树
+    public TreeNode searchBST(TreeNode root, int val) {
+        if (root == null || root.val == val) {
+            return root;
+        }
+        TreeNode left = searchBST(root.left, val);
+        if (left != null) {
+            return left;
+        }
+        return searchBST(root.right, val);
+    }
+}
+
+class Solution {
+    // 递归，利用二叉搜索树特点，优化
+    public TreeNode searchBST(TreeNode root, int val) {
+        if (root == null || root.val == val) {
+            return root;
+        }
+        if (val < root.val) {
+            return searchBST(root.left, val);
+        } else {
+            return searchBST(root.right, val);
+        }
+    }
+}
+
+class Solution {
+    // 迭代，普通二叉树
+    public TreeNode searchBST(TreeNode root, int val) {
+        if (root == null || root.val == val) {
+            return root;
+        }
+        Stack<TreeNode> stack = new Stack<>();
+        stack.push(root);
+        while (!stack.isEmpty()) {
+            TreeNode pop = stack.pop();
+            if (pop.val == val) {
+                return pop;
+            }
+            if (pop.right != null) {
+                stack.push(pop.right);
+            }
+            if (pop.left != null) {
+                stack.push(pop.left);
+            }
+        }
+        return null;
+    }
+}
+
+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 +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/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/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/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)

 ## 其他语言版本