Skip to content

Commit 374bdf6

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0108
No.0108.Convert Sorted Array to Binary Search Tree
1 parent 2376c07 commit 374bdf6

File tree

7 files changed

+148
-147
lines changed

7 files changed

+148
-147
lines changed

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

+60-49
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,22 @@
4343

4444
<!-- 这里可写通用的实现逻辑 -->
4545

46+
**方法一：二分 + 递归**
47+
48+
我们设计一个递归函数 $dfs(l, r)$，表示当前待构造的二叉搜索树的节点值都在数组 `nums` 的下标范围 $[l, r]$ 内。该函数返回构造出的二叉搜索树的根节点。
49+
50+
函数 $dfs(l, r)$ 的执行流程如下：
51+
52+
1. 如果 $l > r$，说明当前数组为空，返回 `null`。
53+
2. 如果 $l \leq r$，取数组中下标为 $mid = \lfloor \frac{l + r}{2} \rfloor$ 的元素作为当前二叉搜索树的根节点，其中 $\lfloor x \rfloor$ 表示对 $x$ 向下取整。
54+
3. 递归地构造当前二叉搜索树的左子树，其根节点的值为数组中下标为 $mid - 1$ 的元素，左子树的节点值都在数组的下标范围 $[l, mid - 1]$ 内。
55+
4. 递归地构造当前二叉搜索树的右子树，其根节点的值为数组中下标为 $mid + 1$ 的元素，右子树的节点值都在数组的下标范围 $[mid + 1, r]$ 内。
56+
5. 返回当前二叉搜索树的根节点。
57+
58+
答案即为函数 $dfs(0, n - 1)$ 的返回值。
59+
60+
时间复杂度 $O(n)$，空间复杂度 $O(\log n)$。其中 $n$ 为数组 `nums` 的长度。
61+
4662
<!-- tabs:start -->
4763

4864
### **Python3**
@@ -57,16 +73,16 @@
5773
# self.left = left
5874
# self.right = right
5975
class Solution:
60-
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
61-
def buildBST(nums, start, end):
62-
if start > end:
76+
def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
77+
def dfs(l, r):
78+
if l > r:
6379
return None
64-
mid = (start + end) >> 1
65-
return TreeNode(
66-
nums[mid], buildBST(nums, start, mid - 1), buildBST(nums, mid + 1, end)
67-
)
80+
mid = (l + r) >> 1
81+
left = dfs(l, mid - 1)
82+
right = dfs(mid + 1, r)
83+
return TreeNode(nums[mid], left, right)
6884

69-
return buildBST(nums, 0, len(nums) - 1)
85+
return dfs(0, len(nums) - 1)
7086
```
7187

7288
### **Java**
@@ -90,19 +106,21 @@ class Solution:
90106
* }
91107
*/
92108
class Solution {
109+
private int[] nums;
110+
93111
public TreeNode sortedArrayToBST(int[] nums) {
94-
return buildBST(nums, 0, nums.length - 1);
112+
this.nums = nums;
113+
return dfs(0, nums.length - 1);
95114
}
96115

97-
private TreeNode buildBST(int[] nums, int start, int end) {
98-
if (start > end) {
116+
private TreeNode dfs(int l, int r) {
117+
if (l > r) {
99118
return null;
100119
}
101-
int mid = (start + end) >> 1;
102-
TreeNode root = new TreeNode(nums[mid]);
103-
root.left = buildBST(nums, start, mid - 1);
104-
root.right = buildBST(nums, mid + 1, end);
105-
return root;
120+
int mid = (l + r) >> 1;
121+
TreeNode left = dfs(l, mid - 1);
122+
TreeNode right = dfs(mid + 1, r);
123+
return new TreeNode(nums[mid], left, right);
106124
}
107125
}
108126
```
@@ -124,18 +142,16 @@ class Solution {
124142
class Solution {
125143
public:
126144
TreeNode* sortedArrayToBST(vector<int>& nums) {
127-
return buildBST(nums, 0, nums.size() - 1);
128-
}
129-
130-
private:
131-
TreeNode* buildBST(vector<int>& nums, int start, int end) {
132-
if (start > end)
133-
return nullptr;
134-
int mid = start + end >> 1;
135-
TreeNode* root = new TreeNode(nums[mid]);
136-
root->left = buildBST(nums, start, mid - 1);
137-
root->right = buildBST(nums, mid + 1, end);
138-
return root;
145+
function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
146+
if (l > r) {
147+
return nullptr;
148+
}
149+
int mid = (l + r) >> 1;
150+
auto left = dfs(l, mid - 1);
151+
auto right = dfs(mid + 1, r);
152+
return new TreeNode(nums[mid], left, right);
153+
};
154+
return dfs(0, nums.size() - 1);
139155
}
140156
};
141157
```
@@ -156,18 +172,16 @@ private:
156172
* @return {TreeNode}
157173
*/
158174
var sortedArrayToBST = function (nums) {
159-
const buildBST = (nums, start, end) => {
160-
if (start > end) {
175+
const dfs = (l, r) => {
176+
if (l > r) {
161177
return null;
162178
}
163-
const mid = (start + end) >> 1;
164-
const root = new TreeNode(nums[mid]);
165-
root.left = buildBST(nums, start, mid - 1);
166-
root.right = buildBST(nums, mid + 1, end);
167-
return root;
179+
const mid = (l + r) >> 1;
180+
const left = dfs(l, mid - 1);
181+
const right = dfs(mid + 1, r);
182+
return new TreeNode(nums[mid], left, right);
168183
};
169-
170-
return buildBST(nums, 0, nums.length - 1);
184+
return dfs(0, nums.length - 1);
171185
};
172186
```
173187

@@ -214,19 +228,16 @@ function sortedArrayToBST(nums: number[]): TreeNode | null {
214228
* }
215229
*/
216230
func sortedArrayToBST(nums []int) *TreeNode {
217-
return buildBST(nums, 0, len(nums)-1)
218-
}
219-
220-
func buildBST(nums []int, start, end int) *TreeNode {
221-
if start > end {
222-
return nil
223-
}
224-
mid := (start + end) >> 1
225-
return &TreeNode{
226-
Val: nums[mid],
227-
Left: buildBST(nums, start, mid-1),
228-
Right: buildBST(nums, mid+1, end),
231+
var dfs func(int, int) *TreeNode
232+
dfs = func(l, r int) *TreeNode {
233+
if l > r {
234+
return nil
235+
}
236+
mid := (l + r) >> 1
237+
left, right := dfs(l, mid-1), dfs(mid+1, r)
238+
return &TreeNode{nums[mid], left, right}
229239
}
240+
return dfs(0, len(nums)-1)
230241
}
231242
```
232243

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

+44-49
Original file line numberDiff line numberDiff line change
@@ -47,16 +47,16 @@
4747
# self.left = left
4848
# self.right = right
4949
class Solution:
50-
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
51-
def buildBST(nums, start, end):
52-
if start > end:
50+
def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
51+
def dfs(l, r):
52+
if l > r:
5353
return None
54-
mid = (start + end) >> 1
55-
return TreeNode(
56-
nums[mid], buildBST(nums, start, mid - 1), buildBST(nums, mid + 1, end)
57-
)
54+
mid = (l + r) >> 1
55+
left = dfs(l, mid - 1)
56+
right = dfs(mid + 1, r)
57+
return TreeNode(nums[mid], left, right)
5858

59-
return buildBST(nums, 0, len(nums) - 1)
59+
return dfs(0, len(nums) - 1)
6060
```
6161

6262
### **Java**
@@ -78,19 +78,21 @@ class Solution:
7878
* }
7979
*/
8080
class Solution {
81+
private int[] nums;
82+
8183
public TreeNode sortedArrayToBST(int[] nums) {
82-
return buildBST(nums, 0, nums.length - 1);
84+
this.nums = nums;
85+
return dfs(0, nums.length - 1);
8386
}
8487

85-
private TreeNode buildBST(int[] nums, int start, int end) {
86-
if (start > end) {
88+
private TreeNode dfs(int l, int r) {
89+
if (l > r) {
8790
return null;
8891
}
89-
int mid = (start + end) >> 1;
90-
TreeNode root = new TreeNode(nums[mid]);
91-
root.left = buildBST(nums, start, mid - 1);
92-
root.right = buildBST(nums, mid + 1, end);
93-
return root;
92+
int mid = (l + r) >> 1;
93+
TreeNode left = dfs(l, mid - 1);
94+
TreeNode right = dfs(mid + 1, r);
95+
return new TreeNode(nums[mid], left, right);
9496
}
9597
}
9698
```
@@ -112,18 +114,16 @@ class Solution {
112114
class Solution {
113115
public:
114116
TreeNode* sortedArrayToBST(vector<int>& nums) {
115-
return buildBST(nums, 0, nums.size() - 1);
116-
}
117-
118-
private:
119-
TreeNode* buildBST(vector<int>& nums, int start, int end) {
120-
if (start > end)
121-
return nullptr;
122-
int mid = start + end >> 1;
123-
TreeNode* root = new TreeNode(nums[mid]);
124-
root->left = buildBST(nums, start, mid - 1);
125-
root->right = buildBST(nums, mid + 1, end);
126-
return root;
117+
function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
118+
if (l > r) {
119+
return nullptr;
120+
}
121+
int mid = (l + r) >> 1;
122+
auto left = dfs(l, mid - 1);
123+
auto right = dfs(mid + 1, r);
124+
return new TreeNode(nums[mid], left, right);
125+
};
126+
return dfs(0, nums.size() - 1);
127127
}
128128
};
129129
```
@@ -144,18 +144,16 @@ private:
144144
* @return {TreeNode}
145145
*/
146146
var sortedArrayToBST = function (nums) {
147-
const buildBST = (nums, start, end) => {
148-
if (start > end) {
147+
const dfs = (l, r) => {
148+
if (l > r) {
149149
return null;
150150
}
151-
const mid = (start + end) >> 1;
152-
const root = new TreeNode(nums[mid]);
153-
root.left = buildBST(nums, start, mid - 1);
154-
root.right = buildBST(nums, mid + 1, end);
155-
return root;
151+
const mid = (l + r) >> 1;
152+
const left = dfs(l, mid - 1);
153+
const right = dfs(mid + 1, r);
154+
return new TreeNode(nums[mid], left, right);
156155
};
157-
158-
return buildBST(nums, 0, nums.length - 1);
156+
return dfs(0, nums.length - 1);
159157
};
160158
```
161159

@@ -202,19 +200,16 @@ function sortedArrayToBST(nums: number[]): TreeNode | null {
202200
* }
203201
*/
204202
func sortedArrayToBST(nums []int) *TreeNode {
205-
return buildBST(nums, 0, len(nums)-1)
206-
}
207-
208-
func buildBST(nums []int, start, end int) *TreeNode {
209-
if start > end {
210-
return nil
211-
}
212-
mid := (start + end) >> 1
213-
return &TreeNode{
214-
Val: nums[mid],
215-
Left: buildBST(nums, start, mid-1),
216-
Right: buildBST(nums, mid+1, end),
203+
var dfs func(int, int) *TreeNode
204+
dfs = func(l, r int) *TreeNode {
205+
if l > r {
206+
return nil
207+
}
208+
mid := (l + r) >> 1
209+
left, right := dfs(l, mid-1), dfs(mid+1, r)
210+
return &TreeNode{nums[mid], left, right}
217211
}
212+
return dfs(0, len(nums)-1)
218213
}
219214
```
220215

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

+10-12
Original file line numberDiff line numberDiff line change
@@ -12,17 +12,15 @@
1212
class Solution {
1313
public:
1414
TreeNode* sortedArrayToBST(vector<int>& nums) {
15-
return buildBST(nums, 0, nums.size() - 1);
16-
}
17-
18-
private:
19-
TreeNode* buildBST(vector<int>& nums, int start, int end) {
20-
if (start > end)
21-
return nullptr;
22-
int mid = start + end >> 1;
23-
TreeNode* root = new TreeNode(nums[mid]);
24-
root->left = buildBST(nums, start, mid - 1);
25-
root->right = buildBST(nums, mid + 1, end);
26-
return root;
15+
function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
16+
if (l > r) {
17+
return nullptr;
18+
}
19+
int mid = (l + r) >> 1;
20+
auto left = dfs(l, mid - 1);
21+
auto right = dfs(mid + 1, r);
22+
return new TreeNode(nums[mid], left, right);
23+
};
24+
return dfs(0, nums.size() - 1);
2725
}
2826
};

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

+9-12
Original file line numberDiff line numberDiff line change
@@ -7,17 +7,14 @@
77
* }
88
*/
99
func sortedArrayToBST(nums []int) *TreeNode {
10-
return buildBST(nums, 0, len(nums)-1)
11-
}
12-
13-
func buildBST(nums []int, start, end int) *TreeNode {
14-
if start > end {
15-
return nil
16-
}
17-
mid := (start + end) >> 1
18-
return &TreeNode{
19-
Val: nums[mid],
20-
Left: buildBST(nums, start, mid-1),
21-
Right: buildBST(nums, mid+1, end),
10+
var dfs func(int, int) *TreeNode
11+
dfs = func(l, r int) *TreeNode {
12+
if l > r {
13+
return nil
14+
}
15+
mid := (l + r) >> 1
16+
left, right := dfs(l, mid-1), dfs(mid+1, r)
17+
return &TreeNode{nums[mid], left, right}
2218
}
19+
return dfs(0, len(nums)-1)
2320
}

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

+10-8
Original file line numberDiff line numberDiff line change
@@ -14,18 +14,20 @@
1414
* }
1515
*/
1616
class Solution {
17+
private int[] nums;
18+
1719
public TreeNode sortedArrayToBST(int[] nums) {
18-
return buildBST(nums, 0, nums.length - 1);
20+
this.nums = nums;
21+
return dfs(0, nums.length - 1);
1922
}
2023

21-
private TreeNode buildBST(int[] nums, int start, int end) {
22-
if (start > end) {
24+
private TreeNode dfs(int l, int r) {
25+
if (l > r) {
2326
return null;
2427
}
25-
int mid = (start + end) >> 1;
26-
TreeNode root = new TreeNode(nums[mid]);
27-
root.left = buildBST(nums, start, mid - 1);
28-
root.right = buildBST(nums, mid + 1, end);
29-
return root;
28+
int mid = (l + r) >> 1;
29+
TreeNode left = dfs(l, mid - 1);
30+
TreeNode right = dfs(mid + 1, r);
31+
return new TreeNode(nums[mid], left, right);
3032
}
3133
}

0 commit comments

Comments
 (0)