Merge pull request #77 from suichenglixin/master

添加添加
0051，0070，0056，0098，0101，0104，0106，0108，0110，0112，0111，0134，0122，0135，0139，0206，0209，0257，0242，0236，0235，0226，0222，0216，0404，0406，0435，0450，0452，0454，0455，0491，0494，0501，0513，0530，0538，0617，0654，0701，0700，0669，0714，0738，0763，0860，0968，1005
的Java版本

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：
 

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：
 

problems/0098.验证二叉搜索树.md

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

problems/0104.二叉树的最大深度.md

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

problems/0106.从中序与后序遍历序列构造二叉树.md

@@ -582,6 +582,47 @@ tree2 的前序遍历是[1 2 3]， 后序遍历是[3 2 1]。
 
 
 Java：
+```java
+class Solution {
+    public TreeNode buildTree(int[] inorder, int[] postorder) {
+        if (inorder.length == 0 || postorder.length == 0) return null;
+        return buildTree(inorder, postorder,0,inorder.length,0,postorder.length);
+    }
+
+    private TreeNode buildTree(int[] inorder, int[] postorder, int infrom, int into,
+                                      int postfrom, int postto) {
+        if (postfrom == postto) return null;
+
+        int rootValue = postorder[postto - 1];
+        TreeNode root = new TreeNode(rootValue);
+
+        if (postfrom + 1 == postto) return root;
+
+        int splitNum = postto - 1;
+        for (int i = infrom; i < into; i++) {
+            if (inorder[i] == rootValue) {
+                splitNum = i;
+                break;
+            }
+        }
+
+        int inLeftBegin = infrom;
+        int inLeftEnd = splitNum;
+        int inRightBegin = splitNum + 1;
+        int inRightEnd = into;
+
+        int postLeftBegin = postfrom;
+        int postLeftEnd = postLeftBegin + (splitNum - inLeftBegin);
+        int postRightBegin = postLeftBegin + (splitNum - inLeftBegin);
+        int postRightEnd = postto - 1;
+
+        root.left = buildTree(inorder,postorder,inLeftBegin,inLeftEnd,postLeftBegin,postLeftEnd);
+        root.right = buildTree(inorder,postorder,inRightBegin,inRightEnd,postRightBegin,postRightEnd);
+
+        return root;
+    }
+}
+```
 
 
 Python：

problems/0108.将有序数组转换为二叉搜索树.md

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

problems/0110.平衡二叉树.md

@@ -354,6 +354,29 @@ public:
 ## 其他语言版本
 
 Java：
+```java
+class Solution {
+    boolean flag = true;
+    public boolean isBalanced(TreeNode root) {
+        high(root);
+        return flag;
+    }
+
+    private int high (TreeNode root) {
+        if (root == null) return 0;
+        if (flag) {
+            int left = high(root.left);
+            int right = high(root.right);
+
+            if (Math.abs(left - right) > 1) flag = false;
+
+            return Math.max(left,right) + 1;
+        } else {
+            return -1;
+        }
+    }
+}
+```
 
 
 Python：

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

@@ -194,6 +194,20 @@ public:
 
 
 Java：
+```java
+class Solution {
+    public int minDepth(TreeNode root) {
+        if (root == null) return 0;
+        int leftDeep = minDepth(root.left);
+        int rightDeep = minDepth(root.right);
+        
+        if (root.left == null && root.right != null) return 1+rightDeep;
+        if (root.left != null && root.right == null) return 1+leftDeep;
+
+        return Math.min(leftDeep,rightDeep)+1;
+    }
+}
+```
 
 Python：
 

problems/0112.路径总和.md

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

problems/0122.买卖股票的最佳时机II.md

@@ -135,7 +135,23 @@ 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：
 

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：
 

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：
 

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：
 

problems/0206.翻转链表.md

@@ -102,6 +102,24 @@ public:
 
 
 Java：
+```java
+class Solution {
+    public ListNode reverseList(ListNode head) {
+        if (head == null || head.next == null) return head;
+        ListNode last = head;
+        ListNode cur = head.next;
+        head.next = null;
+        while (cur.next != null) {
+            ListNode tmp = cur.next;
+            cur.next = last;
+            last = cur;
+            cur = tmp;
+        }
+        cur.next = last;
+        return cur;
+    }
+}
+```
 
 
 Python：

problems/0209.长度最小的子数组.md

@@ -148,7 +148,24 @@ class Solution:
 
 
 Java：
-
+```java
+class Solution {
+    public int minSubArrayLen(int target, int[] nums) {
+        Integer size = Integer.MAX_VALUE;
+        int from = 0;
+        int to = 0;
+        int sum = 0;
+        while (to < nums.length) {
+            sum += nums[to++];
+            while (sum >= target) {
+                size = Math.min(size,to - from);
+                sum -= nums[from++];
+            }
+        }
+        return size == Integer.MAX_VALUE ? 0 : size;
+    }
+}
+```
 
 Python：
 

problems/0216.组合总和III.md

@@ -227,7 +227,30 @@ public:
 
 
 Java：
+```java
+class Solution {
+    private List<Integer> path = new ArrayList<>();
+    private List<List<Integer>> res = new ArrayList<>();
+    public List<List<Integer>> combinationSum3(int k, int n) {
+        backtracking(k, n, 1);
+        return res;
+    }
 
+    private void backtracking (int k, int count, int start) {
+        if (count == 0 && k == 0) {
+            res.add(new ArrayList<>(path));
+            return;
+        }
+
+        for (int i = start; i <= 9; i++) {
+            path.add(i);
+            backtracking(k - 1, count - i, i + 1);
+            path.remove(path.size() - 1);
+        }
+    }
+
+}
+```
 
 Python：
 

problems/0222.完全二叉树的节点个数.md

@@ -194,7 +194,18 @@ public:
 
 
 Java：
+```java
+class Solution {
+    public int countNodes(TreeNode root) {
+        if (root == null) return 0;
 
+        int leftnum = countNodes(root.left);
+        int rightnum = countNodes(root.right);
+
+        return leftnum + rightnum + 1;
+    }
+}
+```
 
 Python：
 

problems/0226.翻转二叉树.md

@@ -203,7 +203,25 @@ public:
 
 
 Java：
+```java
+class Solution {
+    public TreeNode invertTree(TreeNode root) {
+        invert(root);
+        return root;
+    }
 
+    private static void invert (TreeNode root) {
+        if (root == null) return;
+
+        invert(root.left);
+        TreeNode t = root.left;
+        root.left = root.right;
+        root.right = t;
+        
+        invert(root.left);
+    }
+}
+```
 
 Python：
 

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：
 

problems/0236.二叉树的最近公共祖先.md

@@ -223,7 +223,20 @@ public:
 
 
 Java：
-
+```java
+class Solution {
+    TreeNode pre;
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == null || root.val == p.val ||root.val == q.val) return root;
+        TreeNode left = lowestCommonAncestor(root.left,p,q);
+        TreeNode right = lowestCommonAncestor(root.right,p,q);
+        if (left != null && right != null) return root;
+        else if (left == null && right != null) return right;
+        else if (left != null && right == null) return left;
+        else return null;
+    }
+}
+```
 
 Python：
 

problems/0242.有效的字母异位词.md

@@ -88,6 +88,7 @@ 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;

problems/0257.二叉树的所有路径.md

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

problems/0404.左叶子之和.md

@@ -204,7 +204,6 @@ class Solution {
 
 
 
-
 Python：
 
 
@@ -217,5 +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>
 

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：
 

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：
 

problems/0450.删除二叉搜索树中的节点.md

@@ -251,7 +251,34 @@ 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：
 

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：
 

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：
 

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：

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：
 

problems/0501.二叉搜索树中的众数.md

@@ -344,7 +344,47 @@ public:
 
 
 Java：
+```java
+class Solution {
+    private LinkedList<Integer> list = new LinkedList<>();
+    private int currentValue;
+    private int count;
+    private int maxCount;
+    public int[] findMode(TreeNode root) {
+        count = 0;
+        maxCount = 0;
+        currentValue = root.val;
+        findModeTrl(root);
+        int[] res = new int[list.size()];
+        for (int i = 0; i < res.length; i++) {
+            res[i] = list.get(i);
+        }
+        return res;
+    }
 
+    private void findModeTrl (TreeNode root) {
+        if (root == null) return;
+        findModeTrl(root.left);
+        if (root.val == currentValue) {
+            count++;
+        } else {
+            currentValue = root.val;
+            count = 1;
+        }
+
+        if (count == maxCount) {
+            list.add(root.val);
+        } else if (count > maxCount) {
+            maxCount = count;
+            list.clear();
+            list.add(currentValue);
+        }
+
+        findModeTrl(root.right);
+    }
+}
+
+```
 
 Python：
 

problems/0513.找树左下角的值.md

@@ -217,7 +217,29 @@ public:
 
 
 Java：
+```java
+class Solution {
+    private int Deep = -1;
+    private int value = 0;
+    public int findBottomLeftValue(TreeNode root) {
+        value = root.val;
+        findLeftValue(root,0);
+        return value;
+    }
 
+    private void findLeftValue (TreeNode root,int deep) {
+        if (root == null) return;
+        if (root.left == null && root.right == null) {
+            if (deep > Deep) {
+                value = root.val;
+                Deep = deep;
+            }
+        }
+        if (root.left != null) findLeftValue(root.left,deep + 1);
+        if (root.right != null) findLeftValue(root.right,deep + 1);
+    }
+}
+```
 
 Python：
 

problems/0530.二叉搜索树的最小绝对差.md

@@ -151,7 +151,26 @@ public:
 
 
 Java：
+```java
+class Solution {
+    private TreeNode pre = null;
+    private int res = Integer.MAX_VALUE;
+    public int getMinimumDifference(TreeNode root) {
+        getMiniDiff(root);
+        return res;
+    }
 
+    private void getMiniDiff (TreeNode root) {
+        if (root == null) return;
+        getMiniDiff(root.left);
+        if (pre != null) {
+            res = Math.min(root.val - pre.val,res);
+        }
+        pre = root;
+        getMiniDiff(root.right);
+    }
+}
+```
 
 Python：
 

problems/0538.把二叉搜索树转换为累加树.md

@@ -173,7 +173,23 @@ public:
 
 
 Java：
+```java
+class Solution {
+    private int count = 0;
+    public TreeNode convertBST(TreeNode root) {
+        convert(root);
+        return root;
+    }
 
+    private void convert (TreeNode root) {
+        if (root == null) return;
+        convert(root.right);
+        count += root.val;
+        root.val = count;
+        convert(root.left);
+    }
+}
+```
 
 Python：
 

problems/0617.合并二叉树.md

@@ -256,7 +256,19 @@ public:
 
 
 Java：
+```java
+class Solution {
+    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
+        if (root1 == null) return root2;
+        if (root2 == null) return root1;
 
+        TreeNode newRoot = new TreeNode(root1.val + root2.val);
+        newRoot.left = mergeTrees(root1.left,root2.left);
+        newRoot.right = mergeTrees(root1.right,root2.right);
+        return newRoot;
+    }
+}
+```
 
 Python：
 

problems/0654.最大二叉树.md

@@ -224,7 +224,31 @@ root->right = traversal(nums, maxValueIndex + 1, right);
 
 
 Java：
+```java
+class Solution {
+    public TreeNode constructMaximumBinaryTree(int[] nums) {
+        if (nums.length == 0) return null;
+        return constructMaximumBinaryTree(nums,0,nums.length);
+    }
 
+    private TreeNode constructMaximumBinaryTree(int[] nums, int begin, int end) {
+        if (begin == end) return null;
+
+        int rootValue = nums[begin];
+        int index = begin;
+        for (int i = begin; i < end ; i++) {
+            if (nums[i] > rootValue) {
+                rootValue = nums[i];
+                index = i;
+            }
+        }
+        TreeNode root = new TreeNode(rootValue);
+        root.left = constructMaximumBinaryTree(nums, begin,index);
+        root.right = constructMaximumBinaryTree(nums,index+1,end);
+        return root;
+    }
+}
+```
 
 Python：
 

problems/0669.修剪二叉搜索树.md

@@ -242,7 +242,30 @@ public:
 
 
 Java：
+```java
+class Solution {
+    public TreeNode trimBST(TreeNode root, int low, int high) {
+        root = trim(root,low,high);
+        return root;
+    }
 
+    private static TreeNode trim(TreeNode root,int low, int high) {
+        if (root == null ) return null;
+        if (root.val < low) {
+            return trim(root.right,low,high);
+        }
+        if (root.val > high) {
+            return trim(root.left,low,high);
+        }
+
+        root.left = trim(root.left,low,high);
+        root.right = trim(root.right,low,high);
+
+        return root;
+    }
+}
+
+```
 
 Python：
 

problems/0700.二叉搜索树中的搜索.md

@@ -142,7 +142,16 @@ public:
 
 
 Java：
-
+```java
+class Solution {
+    public TreeNode searchBST(TreeNode root, int val) {
+        if (root == null) return null;
+        if (root.val == val) return root;
+        if (root.val > val) return searchBST(root.left, val);
+        return searchBST(root.right, val);
+    }
+}
+```
 
 Python：
 

problems/0701.二叉搜索树中的插入操作.md

@@ -16,7 +16,7 @@
 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回任意有效的结果。
 
 ![701.二叉搜索树中的插入操作](https://img-blog.csdnimg.cn/20201019173259554.png)
- 
+
 提示：
 
 * 给定的树上的节点数介于 0 和 10^4 之间
@@ -208,6 +208,30 @@ 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;
+    }
+}
+```
 
 
 Python：

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：
 

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：

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：
 

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：
 

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：

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：