+ * 时间复杂度：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 {
diff --git a/problems/0055.跳跃游戏.md b/problems/0055.跳跃游戏.md
index 179ac246..a25c831a 100644
--- 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：
diff --git a/problems/0056.合并区间.md b/problems/0056.合并区间.md
index f939325f..e84a1634 100644
--- a/problems/0056.合并区间.md
+++ b/problems/0056.合并区间.md
@@ -137,7 +137,35 @@ public:
Java：
+```java
+class Solution {
+ public int[][] merge(int[][] intervals) {
+ List
+ * 时间复杂度：O(n)
+ */
+ public boolean isBalanced(TreeNode root) {
+ if (root == null) {
+ return true;
+ }
+ Stack
+ * 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：
diff --git a/problems/0206.翻转链表.md b/problems/0206.翻转链表.md
index b465cdf9..886bbfcd 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0070.爬楼梯完全背包版本.md b/problems/0070.爬楼梯完全背包版本.md
index beda45d5..d6b12450 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0098.验证二叉搜索树.md b/problems/0098.验证二叉搜索树.md
index ddd634b4..45f2308b 100644
--- a/problems/0098.验证二叉搜索树.md
+++ b/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：
@@ -286,4 +299,4 @@ func isBST(root *TreeNode, min, max int) bool {
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0101.对称二叉树.md b/problems/0101.对称二叉树.md
index 535300af..05a67623 100644
--- a/problems/0101.对称二叉树.md
+++ b/problems/0101.对称二叉树.md
@@ -254,7 +254,94 @@ public:
## 其他语言版本
Java：
+```java
+public class N0101 {
+ /**
+ * 解法1：DFS，递归。
+ */
+ public boolean isSymmetric2(TreeNode root) {
+ if (root == null) {
+ return false;
+ }
+ return compare(root.left, root.right);
+ }
+
+ private boolean compare(TreeNode left, TreeNode right) {
+ if (left == null && right == null) {
+ return true;
+ }
+ if (left != null && right == null) {
+ return false;
+ }
+ if (left == null && right != null) {
+ return false;
+ }
+
+ if (left.val == right.val) {
+ return compare(left.left, right.right) && compare(left.right, right.left);
+ }
+
+ return false;
+ }
+
+ /**
+ * 解法2：DFS，迭代
+ */
+ public boolean isSymmetric3(TreeNode root) {
+ if (root == null) {
+ return false;
+ }
+
+ if (!equal(root.left, root.right)) {
+ return false;
+ }
+
+ Deque
\ No newline at end of file
+
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 0781e01d..9b5f9ed5 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -420,54 +420,236 @@ public:
Java：
```Java
+// 102.二叉树的层序遍历
class Solution {
- public List
+
\ No newline at end of file
diff --git a/problems/0106.从中序与后序遍历序列构造二叉树.md b/problems/0106.从中序与后序遍历序列构造二叉树.md
index 5533a818..e51cf08b 100644
--- a/problems/0106.从中序与后序遍历序列构造二叉树.md
+++ b/problems/0106.从中序与后序遍历序列构造二叉树.md
@@ -587,7 +587,6 @@ 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) {
// 没有元素了
@@ -630,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)
-
+
\ No newline at end of file
diff --git a/problems/0108.将有序数组转换为二叉搜索树.md b/problems/0108.将有序数组转换为二叉搜索树.md
index 12d47e6a..952dc687 100644
--- a/problems/0108.将有序数组转换为二叉搜索树.md
+++ b/problems/0108.将有序数组转换为二叉搜索树.md
@@ -209,6 +209,26 @@ public:
Java：
+```java
+class Solution {
+ public TreeNode sortedArrayToBST(int[] nums) {
+ return sortArr(nums,0,nums.length);
+ }
+
+ private TreeNode sortArr(int[] nums, int lo, int hi) {
+ if (lo == hi) return null;
+ int rootIdx = (lo + hi)/2;
+
+ int rootValue = nums[rootIdx];
+ TreeNode root = new TreeNode(rootValue);
+
+ root.left = sortArr(nums,lo,rootIdx);
+ root.right = sortArr(nums,rootIdx+1,hi);
+
+ return root;
+ }
+}
+```
Python：
@@ -223,4 +243,4 @@ Go：
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0110.平衡二叉树.md b/problems/0110.平衡二叉树.md
index ac66cc40..da71ccb2 100644
--- a/problems/0110.平衡二叉树.md
+++ b/problems/0110.平衡二叉树.md
@@ -355,6 +355,146 @@ 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
\ No newline at end of file
+
diff --git a/problems/0111.二叉树的最小深度.md b/problems/0111.二叉树的最小深度.md
index 6c6b4632..4f79b334 100644
--- a/problems/0111.二叉树的最小深度.md
+++ b/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：
diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index 718a2f5b..deee84cf 100644
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@@ -305,6 +305,24 @@ public:
Java：
+```java
+class Solution {
+ private boolean flag = false;
+ public boolean hasPathSum(TreeNode root, int targetSum) {
+ has_2(root,targetSum);
+ return flag;
+ }
+
+ public void has_2 (TreeNode root, int count) {
+ if (root == null) return;
+ if (root.left == null && root.right == null && count == root.val) {
+ flag = true;
+ }
+ if (root.left != null) has_2(root.left,count - root.val);
+ if (root.right != null) has_2(root.right,count - root.val);
+ }
+}
+```
Python：
@@ -387,4 +405,4 @@ let pathSum = function (root, targetSum) {
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0122.买卖股票的最佳时机II.md b/problems/0122.买卖股票的最佳时机II.md
index 1a9b4f7f..249d44a7 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0134.加油站.md b/problems/0134.加油站.md
index 9c72e84d..393e4627 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0135.分发糖果.md b/problems/0135.分发糖果.md
index 0595cff6..fedf8765 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0139.单词拆分.md b/problems/0139.单词拆分.md
index ec996565..c6d8e43b 100644
--- a/problems/0139.单词拆分.md
+++ b/problems/0139.单词拆分.md
@@ -232,7 +232,23 @@ public:
Java：
+```java
+class Solution {
+ public boolean wordBreak(String s, List
+
\ No newline at end of file
diff --git a/problems/0142.环形链表II.md b/problems/0142.环形链表II.md
index 9622affc..7556b854 100644
--- 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：
diff --git a/problems/0151.翻转字符串里的单词.md b/problems/0151.翻转字符串里的单词.md
index d81c139d..d9ecfc12 100644
--- a/problems/0151.翻转字符串里的单词.md
+++ b/problems/0151.翻转字符串里的单词.md
@@ -213,6 +213,74 @@ public:
Java：
+```Java
+class Solution {
+ /**
+ * 不使用Java内置方法实现
+ *
+
\ No newline at end of file
diff --git a/problems/0209.长度最小的子数组.md b/problems/0209.长度最小的子数组.md
index 1b00c4e3..0aaa466e 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0216.组合总和III.md b/problems/0216.组合总和III.md
index 11a8eb8f..21230e0f 100644
--- a/problems/0216.组合总和III.md
+++ b/problems/0216.组合总和III.md
@@ -227,7 +227,39 @@ public:
Java：
+```java
+class Solution {
+ List
+
\ No newline at end of file
diff --git a/problems/0222.完全二叉树的节点个数.md b/problems/0222.完全二叉树的节点个数.md
index 367fa717..991d21f3 100644
--- a/problems/0222.完全二叉树的节点个数.md
+++ b/problems/0222.完全二叉树的节点个数.md
@@ -194,7 +194,18 @@ public:
Java：
+```java
+class Solution {
+ public int countNodes(TreeNode root) {
+ if (root == null) return 0;
+ int leftnum = countNodes(root.left);
+ int rightnum = countNodes(root.right);
+
+ return leftnum + rightnum + 1;
+ }
+}
+```
Python：
@@ -208,4 +219,4 @@ Go：
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0226.翻转二叉树.md b/problems/0226.翻转二叉树.md
index f5626ea0..7876eb99 100644
--- a/problems/0226.翻转二叉树.md
+++ b/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：
@@ -230,4 +248,4 @@ func invertTree(root *TreeNode) *TreeNode {
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0235.二叉搜索树的最近公共祖先.md b/problems/0235.二叉搜索树的最近公共祖先.md
index cb9de8b0..93642de5 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0236.二叉树的最近公共祖先.md b/problems/0236.二叉树的最近公共祖先.md
index 17096d48..9a8c3948 100644
--- a/problems/0236.二叉树的最近公共祖先.md
+++ b/problems/0236.二叉树的最近公共祖先.md
@@ -223,7 +223,20 @@ public:
Java：
-
+```java
+class Solution {
+ TreeNode pre;
+ public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+ if (root == null || root.val == p.val ||root.val == q.val) return root;
+ TreeNode left = lowestCommonAncestor(root.left,p,q);
+ TreeNode right = lowestCommonAncestor(root.right,p,q);
+ if (left != null && right != null) return root;
+ else if (left == null && right != null) return right;
+ else if (left != null && right == null) return left;
+ else return null;
+ }
+}
+```
Python：
@@ -237,4 +250,4 @@ Go：
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0242.有效的字母异位词.md b/problems/0242.有效的字母异位词.md
index 89186620..1927f476 100644
--- a/problems/0242.有效的字母异位词.md
+++ b/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;
@@ -138,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)
-
+
\ No newline at end of file
diff --git a/problems/0257.二叉树的所有路径.md b/problems/0257.二叉树的所有路径.md
index a104b27c..73387257 100644
--- a/problems/0257.二叉树的所有路径.md
+++ b/problems/0257.二叉树的所有路径.md
@@ -280,9 +280,48 @@ public:
## 其他语言版本
-
Java：
+```Java
+class Solution {
+ /**
+ * 递归法
+ */
+ public List
+
\ No newline at end of file
diff --git a/problems/0347.前K个高频元素.md b/problems/0347.前K个高频元素.md
index 1902bd68..0e70f553 100644
--- 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
+
\ No newline at end of file
diff --git a/problems/0404.左叶子之和.md b/problems/0404.左叶子之和.md
index da4ed666..0290dccd 100644
--- a/problems/0404.左叶子之和.md
+++ b/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)
+
diff --git a/problems/0406.根据身高重建队列.md b/problems/0406.根据身高重建队列.md
index b5260a8c..2ef0a2fd 100644
--- 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
+
\ No newline at end of file
diff --git a/problems/0435.无重叠区间.md b/problems/0435.无重叠区间.md
index 3df496f4..4341f3b8 100644
--- 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
+
\ No newline at end of file
diff --git a/problems/0450.删除二叉搜索树中的节点.md b/problems/0450.删除二叉搜索树中的节点.md
index 6e38b4fe..604fb376 100644
--- a/problems/0450.删除二叉搜索树中的节点.md
+++ b/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：
@@ -303,4 +330,4 @@ func deleteNode1(root *TreeNode)*TreeNode{
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0452.用最少数量的箭引爆气球.md b/problems/0452.用最少数量的箭引爆气球.md
index 7372ea92..f62fb153 100644
--- 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
+
\ No newline at end of file
diff --git a/problems/0455.分发饼干.md b/problems/0455.分发饼干.md
index ca3eba74..f57a7fa6 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0491.递增子序列.md b/problems/0491.递增子序列.md
index 5deec0ee..5e36d6be 100644
--- a/problems/0491.递增子序列.md
+++ b/problems/0491.递增子序列.md
@@ -200,6 +200,32 @@ public:
Java：
+```java
+class Solution {
+ private List
+
\ No newline at end of file
diff --git a/problems/0494.目标和.md b/problems/0494.目标和.md
index 2fb2a5eb..1782c88c 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0501.二叉搜索树中的众数.md b/problems/0501.二叉搜索树中的众数.md
index 0e8c0d0e..b555692f 100644
--- a/problems/0501.二叉搜索树中的众数.md
+++ b/problems/0501.二叉搜索树中的众数.md
@@ -344,7 +344,47 @@ public:
Java：
+```java
+class Solution {
+ private LinkedList
+
\ No newline at end of file
diff --git a/problems/0513.找树左下角的值.md b/problems/0513.找树左下角的值.md
index 19c870c3..e3be8905 100644
--- a/problems/0513.找树左下角的值.md
+++ b/problems/0513.找树左下角的值.md
@@ -217,7 +217,29 @@ public:
Java：
+```java
+class Solution {
+ private int Deep = -1;
+ private int value = 0;
+ public int findBottomLeftValue(TreeNode root) {
+ value = root.val;
+ findLeftValue(root,0);
+ return value;
+ }
+ private void findLeftValue (TreeNode root,int deep) {
+ if (root == null) return;
+ if (root.left == null && root.right == null) {
+ if (deep > Deep) {
+ value = root.val;
+ Deep = deep;
+ }
+ }
+ if (root.left != null) findLeftValue(root.left,deep + 1);
+ if (root.right != null) findLeftValue(root.right,deep + 1);
+ }
+}
+```
Python：
@@ -231,4 +253,4 @@ Go：
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0516.最长回文子序列.md b/problems/0516.最长回文子序列.md
index 813e75f5..d7acef99 100644
--- 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：
diff --git a/problems/0530.二叉搜索树的最小绝对差.md b/problems/0530.二叉搜索树的最小绝对差.md
index d5abc692..87ed222e 100644
--- a/problems/0530.二叉搜索树的最小绝对差.md
+++ b/problems/0530.二叉搜索树的最小绝对差.md
@@ -151,7 +151,26 @@ public:
Java：
+```java
+class Solution {
+ private TreeNode pre = null;
+ private int res = Integer.MAX_VALUE;
+ public int getMinimumDifference(TreeNode root) {
+ getMiniDiff(root);
+ return res;
+ }
+ private void getMiniDiff (TreeNode root) {
+ if (root == null) return;
+ getMiniDiff(root.left);
+ if (pre != null) {
+ res = Math.min(root.val - pre.val,res);
+ }
+ pre = root;
+ getMiniDiff(root.right);
+ }
+}
+```
Python：
@@ -165,4 +184,4 @@ Go：
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0538.把二叉搜索树转换为累加树.md b/problems/0538.把二叉搜索树转换为累加树.md
index a5f4c43c..a44452e2 100644
--- a/problems/0538.把二叉搜索树转换为累加树.md
+++ b/problems/0538.把二叉搜索树转换为累加树.md
@@ -173,7 +173,23 @@ public:
Java：
+```java
+class Solution {
+ private int count = 0;
+ public TreeNode convertBST(TreeNode root) {
+ convert(root);
+ return root;
+ }
+ private void convert (TreeNode root) {
+ if (root == null) return;
+ convert(root.right);
+ count += root.val;
+ root.val = count;
+ convert(root.left);
+ }
+}
+```
Python：
@@ -187,4 +203,4 @@ Go：
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0617.合并二叉树.md b/problems/0617.合并二叉树.md
index adc0703b..9836f568 100644
--- a/problems/0617.合并二叉树.md
+++ b/problems/0617.合并二叉树.md
@@ -256,7 +256,19 @@ public:
Java：
+```java
+class Solution {
+ public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
+ if (root1 == null) return root2;
+ if (root2 == null) return root1;
+ TreeNode newRoot = new TreeNode(root1.val + root2.val);
+ newRoot.left = mergeTrees(root1.left,root2.left);
+ newRoot.right = mergeTrees(root1.right,root2.right);
+ return newRoot;
+ }
+}
+```
Python：
@@ -270,4 +282,4 @@ Go：
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0654.最大二叉树.md b/problems/0654.最大二叉树.md
index af133e0c..ef417078 100644
--- a/problems/0654.最大二叉树.md
+++ b/problems/0654.最大二叉树.md
@@ -224,7 +224,31 @@ root->right = traversal(nums, maxValueIndex + 1, right);
Java：
+```java
+class Solution {
+ public TreeNode constructMaximumBinaryTree(int[] nums) {
+ if (nums.length == 0) return null;
+ return constructMaximumBinaryTree(nums,0,nums.length);
+ }
+ private TreeNode constructMaximumBinaryTree(int[] nums, int begin, int end) {
+ if (begin == end) return null;
+
+ int rootValue = nums[begin];
+ int index = begin;
+ for (int i = begin; i < end ; i++) {
+ if (nums[i] > rootValue) {
+ rootValue = nums[i];
+ index = i;
+ }
+ }
+ TreeNode root = new TreeNode(rootValue);
+ root.left = constructMaximumBinaryTree(nums, begin,index);
+ root.right = constructMaximumBinaryTree(nums,index+1,end);
+ return root;
+ }
+}
+```
Python：
@@ -238,4 +262,4 @@ Go：
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0669.修剪二叉搜索树.md b/problems/0669.修剪二叉搜索树.md
index 41f684f4..442ea8fb 100644
--- a/problems/0669.修剪二叉搜索树.md
+++ b/problems/0669.修剪二叉搜索树.md
@@ -242,7 +242,30 @@ public:
Java：
+```java
+class Solution {
+ public TreeNode trimBST(TreeNode root, int low, int high) {
+ root = trim(root,low,high);
+ return root;
+ }
+ private static TreeNode trim(TreeNode root,int low, int high) {
+ if (root == null ) return null;
+ if (root.val < low) {
+ return trim(root.right,low,high);
+ }
+ if (root.val > high) {
+ return trim(root.left,low,high);
+ }
+
+ root.left = trim(root.left,low,high);
+ root.right = trim(root.right,low,high);
+
+ return root;
+ }
+}
+
+```
Python：
@@ -256,4 +279,4 @@ Go：
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0700.二叉搜索树中的搜索.md b/problems/0700.二叉搜索树中的搜索.md
index 5c1cdfdf..077d08a2 100644
--- a/problems/0700.二叉搜索树中的搜索.md
+++ b/problems/0700.二叉搜索树中的搜索.md
@@ -140,12 +140,61 @@ public:
## 其他语言版本
-
Java：
+递归法：
+```java
+class Solution {
+ public TreeNode searchBST(TreeNode root, int val) {
+ if (root == null) return null;
+ if (root.val == val) return root;
+ else if (root.val > val) return searchBST(root.left, val);
+ else return searchBST(root.right, val);
+ }
+}
+```
+
+迭代法：
+
+```java
+class Solution {
+ public TreeNode searchBST(TreeNode root, int val) {
+ while (root != null)
+ if (val < root.val) root = root.left;
+ else if (val > root.val) root = root.right;
+ else return root;
+ return root;
+ }
+}
+```
+
Python：
+递归法：
+
+```python
+class Solution:
+ def searchBST(self, root: TreeNode, val: int) -> TreeNode:
+ if root is None:
+ return None
+ if val < root.val: return self.searchBST(root.left, val)
+ elif val > root.val: return self.searchBST(root.right, val)
+ else: return root
+```
+
+迭代法：
+
+```python
+class Solution:
+ def searchBST(self, root: TreeNode, val: int) -> TreeNode:
+ while root is not None:
+ if val < root.val: root = root.left
+ elif val > root.val: root = root.right
+ else: return root
+ return root
+```
+
Go：
@@ -156,4 +205,4 @@ Go：
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-
+
\ No newline at end of file
diff --git a/problems/0701.二叉搜索树中的插入操作.md b/problems/0701.二叉搜索树中的插入操作.md
index 760509d9..ee690d04 100644
--- a/problems/0701.二叉搜索树中的插入操作.md
+++ b/problems/0701.二叉搜索树中的插入操作.md
@@ -16,7 +16,7 @@
注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回任意有效的结果。
-
+
提示：
* 给定的树上的节点数介于 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)
-
+
\ No newline at end of file
diff --git a/problems/0704.二分查找.md b/problems/0704.二分查找.md
index bb013d95..c7207364 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0714.买卖股票的最佳时机含手续费.md b/problems/0714.买卖股票的最佳时机含手续费.md
index 92697a64..86954c14 100644
--- 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：
diff --git a/problems/0738.单调递增的数字.md b/problems/0738.单调递增的数字.md
index d423d4d6..dc136028 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0763.划分字母区间.md b/problems/0763.划分字母区间.md
index 1b93edf7..c1474280 100644
--- a/problems/0763.划分字母区间.md
+++ b/problems/0763.划分字母区间.md
@@ -84,7 +84,28 @@ public:
Java：
-
+```java
+class Solution {
+ public List
+
\ No newline at end of file
diff --git a/problems/0968.监控二叉树.md b/problems/0968.监控二叉树.md
index ab2bd2e5..e541ba13 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/1005.K次取反后最大化的数组和.md b/problems/1005.K次取反后最大化的数组和.md
index b2073e14..1653201e 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/1143.最长公共子序列.md b/problems/1143.最长公共子序列.md
index 0664b0d9..19f4cc72 100644
--- 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)
-
+
\ No newline at end of file