18-4sum.md Separated Chinese and English solutions.

gazeldx · gazeldx · commit fe06cddc9a98 · 2025-01-24T07:57:13.000+08:00
diff --git a/en/1-1000/18-4sum.md b/en/1-1000/18-4sum.md
@@ -1,19 +1,14 @@
-# 18. 4Sum - LeetCode Solution
-LeetCode problem link: [18. 4Sum](https://leetcode.com/problems/4sum),
-[18. 四数之和](https://leetcode.cn/problems/4sum)
+# 18. 4Sum - LeetCode Solution Best Practice
+LeetCode link: [18. 4Sum](https://leetcode.com/problems/4sum), difficulty: **Medium**
 
-[中文题解](#中文题解)
-
-## LeetCode problem description
+## Description of "18. 4Sum"
 Given an array `nums` of `n` integers, return _an array of all the **unique** quadruplets_ `[nums[a], nums[b], nums[c], nums[d]]` such that:
 
 * `0 <= a, b, c, d < n`
 * `a`, `b`, `c`, and `d` are **distinct**.
 * `nums[a] + nums[b] + nums[c] + nums[d] == target`
 * You may return the answer in **any order**.
 
-Difficulty: **Medium**
-
 ### [Example 1]
 **Input**: `nums = [1,0,-1,0,-2,2], target = 0`
 
@@ -30,21 +25,14 @@ Difficulty: **Medium**
 - `-10**9 <= target <= 10**9`
 
 ## Intuition
-[中文题解](#中文题解)
-
 1. The idea of this question is the same as [15. 3Sum](15-3sum.md), please click the link to view.
 2. The difference is that `three numbers` becomes `four numbers`, and processing `four numbers` only requires **one more nested loop**.
 3. In addition, the `target` parameter is added, which needs to be brought in as a condition during calculation.
 4. You may have already seen that no matter it is `two numbers`, `three numbers` or `four numbers`, the `Two Pointers Technique` can be used.
 
 ## Complexity
-* Time: `O(n**3)`.
-* Space: `O(n)`.
-
-## Java
-```java
-// Welcome to create a PR to complete the code of this language, thanks!
-```
+* Time: `O(N**3)`.
+* Space: `O(N)`.
 
 ## Python
 ```python
@@ -82,6 +70,11 @@ class Solution:
         return list(results)
 ```
 
+## Java
+```java
+// Welcome to create a PR to complete the code of this language, thanks!
+```
+
 ## C++
 ```cpp
 // Welcome to create a PR to complete the code of this language, thanks!
@@ -131,31 +124,3 @@ class Solution:
 ```
 // Welcome to create a PR to complete the code of this language, thanks!
 ```
-
-## 力扣问题描述
-[18. 四数之和](https://leetcode.cn/problems/4sum), 难度: **中等**。
-
-给你一个由 `n` 个整数组成的数组 `nums` ，和一个目标值 `target` 。请你找出并返回满足下述全部条件且**不重复**的四元组 `[nums[a], nums[b], nums[c], nums[d]]` （若两个四元组元素一一对应，则认为两个四元组重复）：
-
-- `0 <= a, b, c, d < n`
-- `a`、`b`、`c` 和 `d` **互不相同**
-- `nums[a] + nums[b] + nums[c] + nums[d] == target`
-
-你可以按 **任意顺序** 返回答案 。
-
-### [示例 1]
-**输入**: `nums = [1,0,-1,0,-2,2], target = 0`
-
-**输出**: `[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]`
-
-### [示例 2]
-**输入**: `nums = [2,2,2,2,2], target = 8`
-
-**输出**: `[[2,2,2,2]]`
-
-# 中文题解
-## 思路
-1. 本题思路同[15. 三数之和](15-3sum.md), 请点链接查看。
-2. 区别是`三数`变`四数`，处理`四数`，只需要**多加一重嵌套的循环**。
-3. 另外增加了`target`参数，计算时需要把它做为条件带入。
-4. 你可能已经看出来了，不管它是`两数`、`三数`还是`四数`，都可以用`双指针技术`。
diff --git a/en/3001-4000/unorganized.md b/en/3001-4000/unorganized.md
@@ -15,12 +15,12 @@ You want to query information by a student's name.
 `boolean mark` solution.
 
 ## Other Algorithms
-### Binary Search Algorithm
-704
-
-### Fast and Slow Pointers
-27
-
+### Recursion
+* Recursion steps:
+    1. Determine the parameters
+    2. Determine the recursion logic
+    3. Determine the return value
+    4. Determine the exit logic
 
 ## Dynamic programming
 - [647. Palindromic Substrings](https://leetcode.cn/problems/palindromic-substrings/)
@@ -63,12 +63,17 @@ The improved way with a queue is commonly more efficient. Relaxing **All Edges**
 * Find all the prime numbers within 1000000.
 
 ## Skipped problems/solutions
+- 704 Binary Search Algorithm 
+- 27 Fast and Slow Pointers
+
 - 1047 https://leetcode.cn/problems/remove-all-adjacent-duplicates-in-string/
 - 150 https://leetcode.cn/problems/evaluate-reverse-polish-notation/
 - 239 https://leetcode.cn/problems/sliding-window-maximum/ tag `monotonic queue`
 - 347 https://leetcode.cn/problems/top-k-frequent-elements/ tag `heap sort`
 
 ### Binary Tree
+* Remember to add the recursion steps (described above in this doc) first
+
 - 144 https://leetcode.cn/problems/binary-tree-preorder-traversal/
 - 94 https://leetcode.cn/problems/binary-tree-inorder-traversal/
 - 145 https://leetcode.cn/problems/binary-tree-postorder-traversal/
@@ -81,6 +86,7 @@ The improved way with a queue is commonly more efficient. Relaxing **All Edges**
     - 116 https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/
     - 117 https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/
     - 111 https://leetcode.cn/problems/minimum-depth-of-binary-tree/
+    - 513 https://leetcode.cn/problems/find-bottom-left-tree-value
     
 - 104 https://leetcode.cn/problems/maximum-depth-of-binary-tree/
 - 226 https://leetcode.cn/problems/invert-binary-tree/
@@ -90,8 +96,14 @@ The improved way with a queue is commonly more efficient. Relaxing **All Edges**
 
 - 222 https://leetcode.cn/problems/count-complete-tree-nodes/
 - 110 https://leetcode.cn/problems/balanced-binary-tree/ 2 ways
-- 257 https://leetcode.cn/problems/binary-tree-paths/description/
+- 257 https://leetcode.cn/problems/binary-tree-paths/
 - 404 https://leetcode.cn/problems/sum-of-left-leaves/
+- 112 https://leetcode.cn/problems/path-sum/
+- 105 https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
+- 106 https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal/
+- 654 https://leetcode.cn/problems/maximum-binary-tree/
+- 617 https://leetcode.cn/problems/merge-two-binary-trees/
+- 700 https://leetcode.cn/problems/search-in-a-binary-search-tree/
 
 ### Failed in 2 rounds
 - 222 https://leetcode.cn/problems/count-complete-tree-nodes/
diff --git a/zh/1-1000/18-4sum.md b/zh/1-1000/18-4sum.md
@@ -1,50 +1,39 @@
-# 18. 4Sum - LeetCode Solution
-LeetCode problem link: [18. 4Sum](https://leetcode.com/problems/4sum),
-[18. 四数之和](https://leetcode.cn/problems/4sum)
+# 18. 四数之和 - 力扣题解最佳实践
+力扣链接：[18. 四数之和](https://leetcode.cn/problems/4sum), 难度: **中等**。
 
-[中文题解](#中文题解)
-
-## LeetCode problem description
-Given an array `nums` of `n` integers, return _an array of all the **unique** quadruplets_ `[nums[a], nums[b], nums[c], nums[d]]` such that:
+## 力扣“18. 四数之和”问题描述
+给你一个由 `n` 个整数组成的数组 `nums` ，和一个目标值 `target` 。请你找出并返回满足下述全部条件且**不重复**的四元组 `[nums[a], nums[b], nums[c], nums[d]]` （若两个四元组元素一一对应，则认为两个四元组重复）：
 
-* `0 <= a, b, c, d < n`
-* `a`, `b`, `c`, and `d` are **distinct**.
-* `nums[a] + nums[b] + nums[c] + nums[d] == target`
-* You may return the answer in **any order**.
+- `0 <= a, b, c, d < n`
+- `a`、`b`、`c` 和 `d` **互不相同**
+- `nums[a] + nums[b] + nums[c] + nums[d] == target`
 
-Difficulty: **Medium**
+你可以按 **任意顺序** 返回答案 。
 
-### [Example 1]
-**Input**: `nums = [1,0,-1,0,-2,2], target = 0`
+### [示例 1]
+**输入**: `nums = [1,0,-1,0,-2,2], target = 0`
 
-**Output**: `[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]`
+**输出**: `[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]`
 
-### [Example 2]
-**Input**: `nums = [2,2,2,2,2], target = 8`
+### [示例 2]
+**输入**: `nums = [2,2,2,2,2], target = 8`
 
-**Output**: `[[2,2,2,2]]`
+**输出**: `[[2,2,2,2]]`
 
-### [Constraints]
+### [约束]
 - `1 <= nums.length <= 200`
 - `-10**9 <= nums[i] <= 10**9`
 - `-10**9 <= target <= 10**9`
 
-## Intuition
-[中文题解](#中文题解)
-
-1. The idea of this question is the same as [15. 3Sum](15-3sum.md), please click the link to view.
-2. The difference is that `three numbers` becomes `four numbers`, and processing `four numbers` only requires **one more nested loop**.
-3. In addition, the `target` parameter is added, which needs to be brought in as a condition during calculation.
-4. You may have already seen that no matter it is `two numbers`, `three numbers` or `four numbers`, the `Two Pointers Technique` can be used.
-
-## Complexity
-* Time: `O(n**3)`.
-* Space: `O(n)`.
+## 思路
+1. 本题思路同[15. 三数之和](15-3sum.md), 请点链接查看。
+2. 区别是`三数`变`四数`，处理`四数`，只需要**多加一重嵌套的循环**。
+3. 另外增加了`target`参数，计算时需要把它做为条件带入。
+4. 你可能已经看出来了，不管它是`两数`、`三数`还是`四数`，都可以用`双指针技术`。
 
-## Java
-```java
-// Welcome to create a PR to complete the code of this language, thanks!
-```
+## 复杂度
+* 时间：`O(N**3)`。
+* 空间：`O(N)`。
 
 ## Python
 ```python
@@ -82,6 +71,11 @@ class Solution:
         return list(results)
 ```
 
+## Java
+```java
+// Welcome to create a PR to complete the code of this language, thanks!
+```
+
 ## C++
 ```cpp
 // Welcome to create a PR to complete the code of this language, thanks!
@@ -131,31 +125,3 @@ class Solution:
 ```
 // Welcome to create a PR to complete the code of this language, thanks!
 ```
-
-## 力扣问题描述
-[18. 四数之和](https://leetcode.cn/problems/4sum), 难度: **中等**。
-
-给你一个由 `n` 个整数组成的数组 `nums` ，和一个目标值 `target` 。请你找出并返回满足下述全部条件且**不重复**的四元组 `[nums[a], nums[b], nums[c], nums[d]]` （若两个四元组元素一一对应，则认为两个四元组重复）：
-
-- `0 <= a, b, c, d < n`
-- `a`、`b`、`c` 和 `d` **互不相同**
-- `nums[a] + nums[b] + nums[c] + nums[d] == target`
-
-你可以按 **任意顺序** 返回答案 。
-
-### [示例 1]
-**输入**: `nums = [1,0,-1,0,-2,2], target = 0`
-
-**输出**: `[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]`
-
-### [示例 2]
-**输入**: `nums = [2,2,2,2,2], target = 8`
-
-**输出**: `[[2,2,2,2]]`
-
-# 中文题解
-## 思路
-1. 本题思路同[15. 三数之和](15-3sum.md), 请点链接查看。
-2. 区别是`三数`变`四数`，处理`四数`，只需要**多加一重嵌套的循环**。
-3. 另外增加了`target`参数，计算时需要把它做为条件带入。
-4. 你可能已经看出来了，不管它是`两数`、`三数`还是`四数`，都可以用`双指针技术`。
