+ * 时间复杂度：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 336cc92f..f246c21a 100644
--- a/problems/0098.验证二叉搜索树.md
+++ b/problems/0098.验证二叉搜索树.md
@@ -254,6 +254,7 @@ public:
Java：
+
```Java
class Solution {
// 递归
@@ -335,4 +336,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..b7d41557 100644
--- a/problems/0101.对称二叉树.md
+++ b/problems/0101.对称二叉树.md
@@ -255,6 +255,108 @@ 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
\ 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 f1f30b71..e51cf08b 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0108.将有序数组转换为二叉搜索树.md b/problems/0108.将有序数组转换为二叉搜索树.md
index 12d47e6a..93dc5fd6 100644
--- 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)
-
+
\ 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..01b6c89c 100644
--- a/problems/0111.二叉树的最小深度.md
+++ b/problems/0111.二叉树的最小深度.md
@@ -195,6 +195,64 @@ 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
\ No newline at end of file
+
diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index 718a2f5b..1b75113e 100644
--- 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)
-
+
\ 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..b28b8dfb 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0226.翻转二叉树.md b/problems/0226.翻转二叉树.md
index f5626ea0..3b96b4f6 100644
--- a/problems/0226.翻转二叉树.md
+++ b/problems/0226.翻转二叉树.md
@@ -204,6 +204,29 @@ 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：
@@ -230,4 +253,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..bd312096 100644
--- a/problems/0236.二叉树的最近公共祖先.md
+++ b/problems/0236.二叉树的最近公共祖先.md
@@ -224,6 +224,43 @@ 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)
-
+
\ 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..385ce2f1 100644
--- a/problems/0501.二叉搜索树中的众数.md
+++ b/problems/0501.二叉搜索树中的众数.md
@@ -345,6 +345,53 @@ public:
Java：
+```Java
+class Solution {
+ ArrayList
+
\ No newline at end of file
diff --git a/problems/0513.找树左下角的值.md b/problems/0513.找树左下角的值.md
index 19c870c3..ac21dc68 100644
--- 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
+
\ 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..903ebf78 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0538.把二叉搜索树转换为累加树.md b/problems/0538.把二叉搜索树转换为累加树.md
index a5f4c43c..209c989b 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0617.合并二叉树.md b/problems/0617.合并二叉树.md
index adc0703b..848454de 100644
--- 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
+
\ No newline at end of file
diff --git a/problems/0654.最大二叉树.md b/problems/0654.最大二叉树.md
index af133e0c..905bcbae 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0669.修剪二叉搜索树.md b/problems/0669.修剪二叉搜索树.md
index 41f684f4..8b9e1f6d 100644
--- 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)
-
+
\ No newline at end of file
diff --git a/problems/0700.二叉搜索树中的搜索.md b/problems/0700.二叉搜索树中的搜索.md
index 5c1cdfdf..277ef681 100644
--- 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
+
\ 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