feat: update solutions to lcci problems: No.04.02~04.04 (doocs#2626)

* No.04.02.Minimum Height Tree
* No.04.03.List of Depth
* No.04.04.Check Balance

Author: yanglbme

lcci/04.02.Minimum Height Tree/README.md

@@ -11,9 +11,15 @@
 
 ### 方法一：递归
 
-先找到数组的中间点，作为二叉搜索树的根节点，然后递归左右子树即可。
+我们设计一个函数 $\text{dfs}(l, r)$，表示构造出从 $l$ 到 $r$ 的子树，那么答案就是 $\text{dfs}(0, \text{len}(nums) - 1)$。
 
-时间复杂度 $O(n)$，空间复杂度 $O(\log n)$。其中 $n$ 为数组长度。
+函数 $\text{dfs}(l, r)$ 的执行过程如下：
+
+1. 如果 $l > r$，返回 $\text{None}$。
+2. 否则，我们计算出中间位置 $mid = \frac{l + r}{2}$，然后构造出根节点，左子树为 $\text{dfs}(l, mid - 1)$，右子树为 $\text{dfs}(mid + 1, r)$。
+3. 最后返回根节点。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组的长度。
 
 <!-- tabs:start -->
 
@@ -28,7 +34,7 @@
 
 class Solution:
     def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
-        def dfs(l, r):
+        def dfs(l: int, r: int) -> TreeNode:
             if l > r:
                 return None
             mid = (l + r) >> 1
@@ -79,7 +85,9 @@ class Solution {
 public:
     TreeNode* sortedArrayToBST(vector<int>& nums) {
         function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
-            if (l > r) return nullptr;
+            if (l > r) {
+                return nullptr;
+            }
             int mid = l + r >> 1;
             return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r));
         };
@@ -160,24 +168,23 @@ function sortedArrayToBST(nums: number[]): TreeNode | null {
 use std::rc::Rc;
 use std::cell::RefCell;
 impl Solution {
-    fn dfs(nums: &Vec<i32>, start: usize, end: usize) -> Option<Rc<RefCell<TreeNode>>> {
-        if start >= end {
+    fn dfs(nums: &Vec<i32>, l: usize, r: usize) -> Option<Rc<RefCell<TreeNode>>> {
+        if l >= r {
             return None;
         }
-        let mid = start + (end - start) / 2;
+        let mid = (l + r) >> 1;
         Some(
             Rc::new(
                 RefCell::new(TreeNode {
                     val: nums[mid],
-                    left: Self::dfs(nums, start, mid),
-                    right: Self::dfs(nums, mid + 1, end),
+                    left: Self::dfs(nums, l, mid),
+                    right: Self::dfs(nums, mid + 1, r),
                 })
             )
         )
     }
     pub fn sorted_array_to_bst(nums: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
-        let end = nums.len();
-        Self::dfs(&nums, 0, end)
+        Self::dfs(&nums, 0, nums.len())
     }
 }
 ```

lcci/04.02.Minimum Height Tree/README_EN.md

@@ -32,7 +32,17 @@ One possible answer is: [0,-3,9,-10,null,5]，which represents the following tre
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Recursion
+
+We design a function `dfs(l, r)`, which constructs a subtree from `l` to `r`. Therefore, the answer is `dfs(0, len(nums) - 1)`.
+
+The execution process of the function `dfs(l, r)` is as follows:
+
+1. If `l > r`, return `None`.
+2. Otherwise, we calculate the middle position `mid = (l + r) / 2`, then construct the root node, the left subtree is `dfs(l, mid - 1)`, and the right subtree is `dfs(mid + 1, r)`.
+3. Finally, return the root node.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the array.
 
 <!-- tabs:start -->
 
@@ -47,7 +57,7 @@ One possible answer is: [0,-3,9,-10,null,5]，which represents the following tre
 
 class Solution:
     def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
-        def dfs(l, r):
+        def dfs(l: int, r: int) -> TreeNode:
             if l > r:
                 return None
             mid = (l + r) >> 1
@@ -98,7 +108,9 @@ class Solution {
 public:
     TreeNode* sortedArrayToBST(vector<int>& nums) {
         function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
-            if (l > r) return nullptr;
+            if (l > r) {
+                return nullptr;
+            }
             int mid = l + r >> 1;
             return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r));
         };
@@ -179,24 +191,23 @@ function sortedArrayToBST(nums: number[]): TreeNode | null {
 use std::rc::Rc;
 use std::cell::RefCell;
 impl Solution {
-    fn dfs(nums: &Vec<i32>, start: usize, end: usize) -> Option<Rc<RefCell<TreeNode>>> {
-        if start >= end {
+    fn dfs(nums: &Vec<i32>, l: usize, r: usize) -> Option<Rc<RefCell<TreeNode>>> {
+        if l >= r {
             return None;
         }
-        let mid = start + (end - start) / 2;
+        let mid = (l + r) >> 1;
         Some(
             Rc::new(
                 RefCell::new(TreeNode {
                     val: nums[mid],
-                    left: Self::dfs(nums, start, mid),
-                    right: Self::dfs(nums, mid + 1, end),
+                    left: Self::dfs(nums, l, mid),
+                    right: Self::dfs(nums, mid + 1, r),
                 })
             )
         )
     }
     pub fn sorted_array_to_bst(nums: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
-        let end = nums.len();
-        Self::dfs(&nums, 0, end)
+        Self::dfs(&nums, 0, nums.len())
     }
 }
 ```

lcci/04.02.Minimum Height Tree/Solution.cpp

@@ -11,7 +11,9 @@ class Solution {
 public:
     TreeNode* sortedArrayToBST(vector<int>& nums) {
         function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
-            if (l > r) return nullptr;
+            if (l > r) {
+                return nullptr;
+            }
             int mid = l + r >> 1;
             return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r));
         };

lcci/04.02.Minimum Height Tree/Solution.py

@@ -8,7 +8,7 @@
 
 class Solution:
     def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
-        def dfs(l, r):
+        def dfs(l: int, r: int) -> TreeNode:
             if l > r:
                 return None
             mid = (l + r) >> 1

lcci/04.02.Minimum Height Tree/Solution.rs

@@ -19,23 +19,22 @@
 use std::rc::Rc;
 use std::cell::RefCell;
 impl Solution {
-    fn dfs(nums: &Vec<i32>, start: usize, end: usize) -> Option<Rc<RefCell<TreeNode>>> {
-        if start >= end {
+    fn dfs(nums: &Vec<i32>, l: usize, r: usize) -> Option<Rc<RefCell<TreeNode>>> {
+        if l >= r {
             return None;
         }
-        let mid = start + (end - start) / 2;
+        let mid = (l + r) >> 1;
         Some(
             Rc::new(
                 RefCell::new(TreeNode {
                     val: nums[mid],
-                    left: Self::dfs(nums, start, mid),
-                    right: Self::dfs(nums, mid + 1, end),
+                    left: Self::dfs(nums, l, mid),
+                    right: Self::dfs(nums, mid + 1, r),
                 })
             )
         )
     }
     pub fn sorted_array_to_bst(nums: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
-        let end = nums.len();
-        Self::dfs(&nums, 0, end)
+        Self::dfs(&nums, 0, nums.len())
     }
 }

lcci/04.03.List of Depth/README_EN.md

@@ -38,7 +38,11 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: BFS Level Order Traversal
+
+We can use the BFS level order traversal method. For each level, we store the values of the current level's nodes into a list, and then add the list to the result array.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the number of nodes in the binary tree.
 
 <!-- tabs:start -->
 

lcci/04.04.Check Balance/README.md

@@ -16,7 +16,7 @@
 函数 $dfs(root)$ 的执行逻辑如下：
 
 -   如果 $root$ 为空，则返回 $0$；
--   否则，我们递归调用 $dfs(root.left)$ 和 $dfs(root.right)$，并判断 $dfs(root.left)$ 和 $dfs(root.right)$ 的返回值是否为 $-1$，如果不为 $-1$，则判断 $abs(dfs(root.left) - dfs(root.right)) <= 1$ 是否成立，如果成立，则返回 $max(dfs(root.left), dfs(root.right)) + 1$，否则返回 $-1$。
+-   否则，我们递归调用 $dfs(root.left)$ 和 $dfs(root.right)$，并判断 $dfs(root.left)$ 和 $dfs(root.right)$ 的返回值是否为 $-1$，如果不为 $-1$，则判断 $abs(dfs(root.left) - dfs(root.right)) \leq 1$ 是否成立，如果成立，则返回 $max(dfs(root.left), dfs(root.right)) + 1$，否则返回 $-1$。
 
 在主函数中，我们只需要调用 $dfs(root)$，并判断其返回值是否为 $-1$，如果不为 $-1$，则返回 `true`，否则返回 `false`。
 
@@ -37,12 +37,13 @@ class Solution:
     def isBalanced(self, root: TreeNode) -> bool:
         def dfs(root: TreeNode):
             if root is None:
-                return 0, True
-            a, b = dfs(root.left)
-            c, d = dfs(root.right)
-            return max(a, c) + 1, abs(a - c) <= 1 and b and d
+                return 0
+            l, r = dfs(root.left), dfs(root.right)
+            if l == -1 or r == -1 or abs(l - r) > 1:
+                return -1
+            return max(l, r) + 1
 
-        return dfs(root)[1]
+        return dfs(root) >= 0
 ```
 
 ```java
@@ -168,32 +169,4 @@ function isBalanced(root: TreeNode | null): boolean {
 
 <!-- tabs:end -->
 
-### 方法二
-
-<!-- tabs:start -->
-
-```python
-# Definition for a binary tree node.
-# class TreeNode:
-#     def __init__(self, x):
-#         self.val = x
-#         self.left = None
-#         self.right = None
-
-
-class Solution:
-    def isBalanced(self, root: TreeNode) -> bool:
-        def dfs(root: TreeNode):
-            if root is None:
-                return 0
-            l, r = dfs(root.left), dfs(root.right)
-            if l == -1 or r == -1 or abs(l - r) > 1:
-                return -1
-            return max(l, r) + 1
-
-        return dfs(root) >= 0
-```
-
-<!-- tabs:end -->
-
 <!-- end -->

lcci/04.04.Check Balance/README_EN.md

@@ -52,7 +52,18 @@ return&nbsp;false.</pre>
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Recursion (Post-order Traversal)
+
+We design a function $dfs(root)$, which returns the height of the tree with $root$ as the root node. If the tree with $root$ as the root node is balanced, it returns the height of the tree, otherwise, it returns $-1$.
+
+The execution logic of the function $dfs(root)$ is as follows:
+
+-   If $root$ is null, then return $0$.
+-   Otherwise, we recursively call $dfs(root.left)$ and $dfs(root.right)$, and check whether the return values of $dfs(root.left)$ and $dfs(root.right)$ are $-1$. If not, we check whether $abs(dfs(root.left) - dfs(root.right)) \leq 1$ holds. If it holds, then return $max(dfs(root.left), dfs(root.right)) + 1$, otherwise return $-1$.
+
+In the main function, we only need to call $dfs(root)$, and check whether its return value is $-1$. If not, return `true`, otherwise return `false`.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the number of nodes in the binary tree.
 
 <!-- tabs:start -->
 
@@ -69,12 +80,13 @@ class Solution:
     def isBalanced(self, root: TreeNode) -> bool:
         def dfs(root: TreeNode):
             if root is None:
-                return 0, True
-            a, b = dfs(root.left)
-            c, d = dfs(root.right)
-            return max(a, c) + 1, abs(a - c) <= 1 and b and d
+                return 0
+            l, r = dfs(root.left), dfs(root.right)
+            if l == -1 or r == -1 or abs(l - r) > 1:
+                return -1
+            return max(l, r) + 1
 
-        return dfs(root)[1]
+        return dfs(root) >= 0
 ```
 
 ```java
@@ -200,32 +212,4 @@ function isBalanced(root: TreeNode | null): boolean {
 
 <!-- tabs:end -->
 
-### Solution 2
-
-<!-- tabs:start -->
-
-```python
-# Definition for a binary tree node.
-# class TreeNode:
-#     def __init__(self, x):
-#         self.val = x
-#         self.left = None
-#         self.right = None
-
-
-class Solution:
-    def isBalanced(self, root: TreeNode) -> bool:
-        def dfs(root: TreeNode):
-            if root is None:
-                return 0
-            l, r = dfs(root.left), dfs(root.right)
-            if l == -1 or r == -1 or abs(l - r) > 1:
-                return -1
-            return max(l, r) + 1
-
-        return dfs(root) >= 0
-```
-
-<!-- tabs:end -->
-
 <!-- end -->

lcci/04.04.Check Balance/Solution.py

@@ -10,9 +10,10 @@ class Solution:
     def isBalanced(self, root: TreeNode) -> bool:
         def dfs(root: TreeNode):
             if root is None:
-                return 0, True
-            a, b = dfs(root.left)
-            c, d = dfs(root.right)
-            return max(a, c) + 1, abs(a - c) <= 1 and b and d
+                return 0
+            l, r = dfs(root.left), dfs(root.right)
+            if l == -1 or r == -1 or abs(l - r) > 1:
+                return -1
+            return max(l, r) + 1
 
-        return dfs(root)[1]
+        return dfs(root) >= 0