feat: add solutions to lc problem: No.0108

No.0108.Convert Sorted Array to Binary Search Tree

Author: yanglbme

solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/README.md

@@ -43,6 +43,22 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：二分 + 递归**
+
+我们设计一个递归函数 $dfs(l, r)$，表示当前待构造的二叉搜索树的节点值都在数组 `nums` 的下标范围 $[l, r]$ 内。该函数返回构造出的二叉搜索树的根节点。
+
+函数 $dfs(l, r)$ 的执行流程如下：
+
+1. 如果 $l > r$，说明当前数组为空，返回 `null`。
+2. 如果 $l \leq r$，取数组中下标为 $mid = \lfloor \frac{l + r}{2} \rfloor$ 的元素作为当前二叉搜索树的根节点，其中 $\lfloor x \rfloor$ 表示对 $x$ 向下取整。
+3. 递归地构造当前二叉搜索树的左子树，其根节点的值为数组中下标为 $mid - 1$ 的元素，左子树的节点值都在数组的下标范围 $[l, mid - 1]$ 内。
+4. 递归地构造当前二叉搜索树的右子树，其根节点的值为数组中下标为 $mid + 1$ 的元素，右子树的节点值都在数组的下标范围 $[mid + 1, r]$ 内。
+5. 返回当前二叉搜索树的根节点。
+
+答案即为函数 $dfs(0, n - 1)$ 的返回值。
+
+时间复杂度 $O(n)$，空间复杂度 $O(\log n)$。其中 $n$ 为数组 `nums` 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -57,16 +73,16 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
-        def buildBST(nums, start, end):
-            if start > end:
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+        def dfs(l, r):
+            if l > r:
                 return None
-            mid = (start + end) >> 1
-            return TreeNode(
-                nums[mid], buildBST(nums, start, mid - 1), buildBST(nums, mid + 1, end)
-            )
+            mid = (l + r) >> 1
+            left = dfs(l, mid - 1)
+            right = dfs(mid + 1, r)
+            return TreeNode(nums[mid], left, right)
 
-        return buildBST(nums, 0, len(nums) - 1)
+        return dfs(0, len(nums) - 1)
 ```
 
 ### **Java**
@@ -90,19 +106,21 @@ class Solution:
  * }
  */
 class Solution {
+    private int[] nums;
+
     public TreeNode sortedArrayToBST(int[] nums) {
-        return buildBST(nums, 0, nums.length - 1);
+        this.nums = nums;
+        return dfs(0, nums.length - 1);
     }
 
-    private TreeNode buildBST(int[] nums, int start, int end) {
-        if (start > end) {
+    private TreeNode dfs(int l, int r) {
+        if (l > r) {
             return null;
         }
-        int mid = (start + end) >> 1;
-        TreeNode root = new TreeNode(nums[mid]);
-        root.left = buildBST(nums, start, mid - 1);
-        root.right = buildBST(nums, mid + 1, end);
-        return root;
+        int mid = (l + r) >> 1;
+        TreeNode left = dfs(l, mid - 1);
+        TreeNode right = dfs(mid + 1, r);
+        return new TreeNode(nums[mid], left, right);
     }
 }
 ```
@@ -124,18 +142,16 @@ class Solution {
 class Solution {
 public:
     TreeNode* sortedArrayToBST(vector<int>& nums) {
-        return buildBST(nums, 0, nums.size() - 1);
-    }
-
-private:
-    TreeNode* buildBST(vector<int>& nums, int start, int end) {
-        if (start > end)
-            return nullptr;
-        int mid = start + end >> 1;
-        TreeNode* root = new TreeNode(nums[mid]);
-        root->left = buildBST(nums, start, mid - 1);
-        root->right = buildBST(nums, mid + 1, end);
-        return root;
+        function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
+            if (l > r) {
+                return nullptr;
+            }
+            int mid = (l + r) >> 1;
+            auto left = dfs(l, mid - 1);
+            auto right = dfs(mid + 1, r);
+            return new TreeNode(nums[mid], left, right);
+        };
+        return dfs(0, nums.size() - 1);
     }
 };
 ```
@@ -156,18 +172,16 @@ private:
  * @return {TreeNode}
  */
 var sortedArrayToBST = function (nums) {
-    const buildBST = (nums, start, end) => {
-        if (start > end) {
+    const dfs = (l, r) => {
+        if (l > r) {
             return null;
         }
-        const mid = (start + end) >> 1;
-        const root = new TreeNode(nums[mid]);
-        root.left = buildBST(nums, start, mid - 1);
-        root.right = buildBST(nums, mid + 1, end);
-        return root;
+        const mid = (l + r) >> 1;
+        const left = dfs(l, mid - 1);
+        const right = dfs(mid + 1, r);
+        return new TreeNode(nums[mid], left, right);
     };
-
-    return buildBST(nums, 0, nums.length - 1);
+    return dfs(0, nums.length - 1);
 };
 ```
 
@@ -214,19 +228,16 @@ function sortedArrayToBST(nums: number[]): TreeNode | null {
  * }
  */
 func sortedArrayToBST(nums []int) *TreeNode {
-	return buildBST(nums, 0, len(nums)-1)
-}
-
-func buildBST(nums []int, start, end int) *TreeNode {
-	if start > end {
-		return nil
-	}
-	mid := (start + end) >> 1
-	return &TreeNode{
-		Val:   nums[mid],
-		Left:  buildBST(nums, start, mid-1),
-		Right: buildBST(nums, mid+1, end),
+	var dfs func(int, int) *TreeNode
+	dfs = func(l, r int) *TreeNode {
+		if l > r {
+			return nil
+		}
+		mid := (l + r) >> 1
+		left, right := dfs(l, mid-1), dfs(mid+1, r)
+		return &TreeNode{nums[mid], left, right}
 	}
+	return dfs(0, len(nums)-1)
 }
 ```
 

solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/README_EN.md

@@ -47,16 +47,16 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
-        def buildBST(nums, start, end):
-            if start > end:
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+        def dfs(l, r):
+            if l > r:
                 return None
-            mid = (start + end) >> 1
-            return TreeNode(
-                nums[mid], buildBST(nums, start, mid - 1), buildBST(nums, mid + 1, end)
-            )
+            mid = (l + r) >> 1
+            left = dfs(l, mid - 1)
+            right = dfs(mid + 1, r)
+            return TreeNode(nums[mid], left, right)
 
-        return buildBST(nums, 0, len(nums) - 1)
+        return dfs(0, len(nums) - 1)
 ```
 
 ### **Java**
@@ -78,19 +78,21 @@ class Solution:
  * }
  */
 class Solution {
+    private int[] nums;
+
     public TreeNode sortedArrayToBST(int[] nums) {
-        return buildBST(nums, 0, nums.length - 1);
+        this.nums = nums;
+        return dfs(0, nums.length - 1);
     }
 
-    private TreeNode buildBST(int[] nums, int start, int end) {
-        if (start > end) {
+    private TreeNode dfs(int l, int r) {
+        if (l > r) {
             return null;
         }
-        int mid = (start + end) >> 1;
-        TreeNode root = new TreeNode(nums[mid]);
-        root.left = buildBST(nums, start, mid - 1);
-        root.right = buildBST(nums, mid + 1, end);
-        return root;
+        int mid = (l + r) >> 1;
+        TreeNode left = dfs(l, mid - 1);
+        TreeNode right = dfs(mid + 1, r);
+        return new TreeNode(nums[mid], left, right);
     }
 }
 ```
@@ -112,18 +114,16 @@ class Solution {
 class Solution {
 public:
     TreeNode* sortedArrayToBST(vector<int>& nums) {
-        return buildBST(nums, 0, nums.size() - 1);
-    }
-
-private:
-    TreeNode* buildBST(vector<int>& nums, int start, int end) {
-        if (start > end)
-            return nullptr;
-        int mid = start + end >> 1;
-        TreeNode* root = new TreeNode(nums[mid]);
-        root->left = buildBST(nums, start, mid - 1);
-        root->right = buildBST(nums, mid + 1, end);
-        return root;
+        function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
+            if (l > r) {
+                return nullptr;
+            }
+            int mid = (l + r) >> 1;
+            auto left = dfs(l, mid - 1);
+            auto right = dfs(mid + 1, r);
+            return new TreeNode(nums[mid], left, right);
+        };
+        return dfs(0, nums.size() - 1);
     }
 };
 ```
@@ -144,18 +144,16 @@ private:
  * @return {TreeNode}
  */
 var sortedArrayToBST = function (nums) {
-    const buildBST = (nums, start, end) => {
-        if (start > end) {
+    const dfs = (l, r) => {
+        if (l > r) {
             return null;
         }
-        const mid = (start + end) >> 1;
-        const root = new TreeNode(nums[mid]);
-        root.left = buildBST(nums, start, mid - 1);
-        root.right = buildBST(nums, mid + 1, end);
-        return root;
+        const mid = (l + r) >> 1;
+        const left = dfs(l, mid - 1);
+        const right = dfs(mid + 1, r);
+        return new TreeNode(nums[mid], left, right);
     };
-
-    return buildBST(nums, 0, nums.length - 1);
+    return dfs(0, nums.length - 1);
 };
 ```
 
@@ -202,19 +200,16 @@ function sortedArrayToBST(nums: number[]): TreeNode | null {
  * }
  */
 func sortedArrayToBST(nums []int) *TreeNode {
-	return buildBST(nums, 0, len(nums)-1)
-}
-
-func buildBST(nums []int, start, end int) *TreeNode {
-	if start > end {
-		return nil
-	}
-	mid := (start + end) >> 1
-	return &TreeNode{
-		Val:   nums[mid],
-		Left:  buildBST(nums, start, mid-1),
-		Right: buildBST(nums, mid+1, end),
+	var dfs func(int, int) *TreeNode
+	dfs = func(l, r int) *TreeNode {
+		if l > r {
+			return nil
+		}
+		mid := (l + r) >> 1
+		left, right := dfs(l, mid-1), dfs(mid+1, r)
+		return &TreeNode{nums[mid], left, right}
 	}
+	return dfs(0, len(nums)-1)
 }
 ```
 

solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.cpp

@@ -12,17 +12,15 @@
 class Solution {
 public:
     TreeNode* sortedArrayToBST(vector<int>& nums) {
-        return buildBST(nums, 0, nums.size() - 1);
-    }
-
-private:
-    TreeNode* buildBST(vector<int>& nums, int start, int end) {
-        if (start > end)
-            return nullptr;
-        int mid = start + end >> 1;
-        TreeNode* root = new TreeNode(nums[mid]);
-        root->left = buildBST(nums, start, mid - 1);
-        root->right = buildBST(nums, mid + 1, end);
-        return root;
+        function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
+            if (l > r) {
+                return nullptr;
+            }
+            int mid = (l + r) >> 1;
+            auto left = dfs(l, mid - 1);
+            auto right = dfs(mid + 1, r);
+            return new TreeNode(nums[mid], left, right);
+        };
+        return dfs(0, nums.size() - 1);
     }
 };

solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.go

@@ -7,17 +7,14 @@
  * }
  */
 func sortedArrayToBST(nums []int) *TreeNode {
-	return buildBST(nums, 0, len(nums)-1)
-}
-
-func buildBST(nums []int, start, end int) *TreeNode {
-	if start > end {
-		return nil
-	}
-	mid := (start + end) >> 1
-	return &TreeNode{
-		Val:   nums[mid],
-		Left:  buildBST(nums, start, mid-1),
-		Right: buildBST(nums, mid+1, end),
+	var dfs func(int, int) *TreeNode
+	dfs = func(l, r int) *TreeNode {
+		if l > r {
+			return nil
+		}
+		mid := (l + r) >> 1
+		left, right := dfs(l, mid-1), dfs(mid+1, r)
+		return &TreeNode{nums[mid], left, right}
 	}
+	return dfs(0, len(nums)-1)
 }

solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.java

@@ -14,18 +14,20 @@
  * }
  */
 class Solution {
+    private int[] nums;
+
     public TreeNode sortedArrayToBST(int[] nums) {
-        return buildBST(nums, 0, nums.length - 1);
+        this.nums = nums;
+        return dfs(0, nums.length - 1);
     }
 
-    private TreeNode buildBST(int[] nums, int start, int end) {
-        if (start > end) {
+    private TreeNode dfs(int l, int r) {
+        if (l > r) {
             return null;
         }
-        int mid = (start + end) >> 1;
-        TreeNode root = new TreeNode(nums[mid]);
-        root.left = buildBST(nums, start, mid - 1);
-        root.right = buildBST(nums, mid + 1, end);
-        return root;
+        int mid = (l + r) >> 1;
+        TreeNode left = dfs(l, mid - 1);
+        TreeNode right = dfs(mid + 1, r);
+        return new TreeNode(nums[mid], left, right);
     }
 }