Skip to content

Commit 836a3a6

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.0108 (#3912)
No.0108.Convert Sorted Array to Binary Search Tree
1 parent acbf443 commit 836a3a6

File tree

10 files changed

+204
-137
lines changed

10 files changed

+204
-137
lines changed

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

+71-47
Original file line numberDiff line numberDiff line change
@@ -59,19 +59,19 @@ tags:
5959

6060
### 方法一：二分 + 递归
6161

62-
我们设计一个递归函数 $dfs(l, r)$，表示当前待构造的二叉搜索树的节点值都在数组 `nums` 的下标范围 $[l, r]$ 内。该函数返回构造出的二叉搜索树的根节点。
62+
我们设计一个递归函数 $\textit{dfs}(l, r)$，表示当前待构造的二叉搜索树的节点值都在数组 $\textit{nums}$ 的下标范围 $[l, r]$ 内。该函数返回构造出的二叉搜索树的根节点。
6363

64-
函数 $dfs(l, r)$ 的执行流程如下：
64+
函数 $\textit{dfs}(l, r)$ 的执行流程如下：
6565

6666
1. 如果 $l > r$，说明当前数组为空，返回 `null`。
67-
2. 如果 $l \leq r$，取数组中下标为 $mid = \lfloor \frac{l + r}{2} \rfloor$ 的元素作为当前二叉搜索树的根节点，其中 $\lfloor x \rfloor$ 表示对 $x$ 向下取整。
68-
3. 递归地构造当前二叉搜索树的左子树，其根节点的值为数组中下标为 $mid - 1$ 的元素，左子树的节点值都在数组的下标范围 $[l, mid - 1]$ 内。
69-
4. 递归地构造当前二叉搜索树的右子树，其根节点的值为数组中下标为 $mid + 1$ 的元素，右子树的节点值都在数组的下标范围 $[mid + 1, r]$ 内。
67+
2. 如果 $l \leq r$，取数组中下标为 $\textit{mid} = \lfloor \frac{l + r}{2} \rfloor$ 的元素作为当前二叉搜索树的根节点，其中 $\lfloor x \rfloor$ 表示对 $x$ 向下取整。
68+
3. 递归地构造当前二叉搜索树的左子树，其根节点的值为数组中下标为 $\textit{mid} - 1$ 的元素，左子树的节点值都在数组的下标范围 $[l, \textit{mid} - 1]$ 内。
69+
4. 递归地构造当前二叉搜索树的右子树，其根节点的值为数组中下标为 $\textit{mid} + 1$ 的元素，右子树的节点值都在数组的下标范围 $[\textit{mid} + 1, r]$ 内。
7070
5. 返回当前二叉搜索树的根节点。
7171

72-
答案即为函数 $dfs(0, n - 1)$ 的返回值。
72+
答案即为函数 $\textit{dfs}(0, n - 1)$ 的返回值。
7373

74-
时间复杂度 $O(n)$，空间复杂度 $O(\log n)$。其中 $n$ 为数组 `nums` 的长度。
74+
时间复杂度 $O(n)$，空间复杂度 $O(\log n)$。其中 $n$ 为数组 $\textit{nums}$ 的长度。
7575

7676
<!-- tabs:start -->
7777

@@ -86,13 +86,11 @@ tags:
8686
# self.right = right
8787
class Solution:
8888
def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
89-
def dfs(l, r):
89+
def dfs(l: int, r: int) -> Optional[TreeNode]:
9090
if l > r:
9191
return None
9292
mid = (l + r) >> 1
93-
left = dfs(l, mid - 1)
94-
right = dfs(mid + 1, r)
95-
return TreeNode(nums[mid], left, right)
93+
return TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r))
9694

9795
return dfs(0, len(nums) - 1)
9896
```
@@ -128,9 +126,7 @@ class Solution {
128126
return null;
129127
}
130128
int mid = (l + r) >> 1;
131-
TreeNode left = dfs(l, mid - 1);
132-
TreeNode right = dfs(mid + 1, r);
133-
return new TreeNode(nums[mid], left, right);
129+
return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r));
134130
}
135131
}
136132
```
@@ -152,14 +148,12 @@ class Solution {
152148
class Solution {
153149
public:
154150
TreeNode* sortedArrayToBST(vector<int>& nums) {
155-
function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
151+
auto dfs = [&](this auto&& dfs, int l, int r) -> TreeNode* {
156152
if (l > r) {
157153
return nullptr;
158154
}
159155
int mid = (l + r) >> 1;
160-
auto left = dfs(l, mid - 1);
161-
auto right = dfs(mid + 1, r);
162-
return new TreeNode(nums[mid], left, right);
156+
return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r));
163157
};
164158
return dfs(0, nums.size() - 1);
165159
}
@@ -184,8 +178,7 @@ func sortedArrayToBST(nums []int) *TreeNode {
184178
return nil
185179
}
186180
mid := (l + r) >> 1
187-
left, right := dfs(l, mid-1), dfs(mid+1, r)
188-
return &TreeNode{nums[mid], left, right}
181+
return &TreeNode{nums[mid], dfs(l, mid-1), dfs(mid+1, r)}
189182
}
190183
return dfs(0, len(nums)-1)
191184
}
@@ -209,16 +202,14 @@ func sortedArrayToBST(nums []int) *TreeNode {
209202
*/
210203

211204
function sortedArrayToBST(nums: number[]): TreeNode | null {
212-
const n = nums.length;
213-
if (n === 0) {
214-
return null;
215-
}
216-
const mid = n >> 1;
217-
return new TreeNode(
218-
nums[mid],
219-
sortedArrayToBST(nums.slice(0, mid)),
220-
sortedArrayToBST(nums.slice(mid + 1)),
221-
);
205+
const dfs = (l: number, r: number): TreeNode | null => {
206+
if (l > r) {
207+
return null;
208+
}
209+
const mid = (l + r) >> 1;
210+
return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r));
211+
};
212+
return dfs(0, nums.length - 1);
222213
}
223214
```
224215

@@ -243,23 +234,24 @@ function sortedArrayToBST(nums: number[]): TreeNode | null {
243234
// }
244235
// }
245236
// }
246-
use std::cell::RefCell;
247237
use std::rc::Rc;
238+
use std::cell::RefCell;
248239
impl Solution {
249-
fn to_bst(nums: &Vec<i32>, start: usize, end: usize) -> Option<Rc<RefCell<TreeNode>>> {
250-
if start >= end {
251-
return None;
252-
}
253-
let mid = start + (end - start) / 2;
254-
Some(Rc::new(RefCell::new(TreeNode {
255-
val: nums[mid],
256-
left: Self::to_bst(nums, start, mid),
257-
right: Self::to_bst(nums, mid + 1, end),
258-
})))
259-
}
260-
261240
pub fn sorted_array_to_bst(nums: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
262-
Self::to_bst(&nums, 0, nums.len())
241+
fn dfs(nums: &Vec<i32>, l: usize, r: usize) -> Option<Rc<RefCell<TreeNode>>> {
242+
if l > r {
243+
return None;
244+
}
245+
let mid = (l + r) / 2;
246+
if mid >= nums.len() {
247+
return None;
248+
}
249+
let mut node = Rc::new(RefCell::new(TreeNode::new(nums[mid])));
250+
node.borrow_mut().left = dfs(nums, l, mid - 1);
251+
node.borrow_mut().right = dfs(nums, mid + 1, r);
252+
Some(node)
253+
}
254+
dfs(&nums, 0, nums.len() - 1)
263255
}
264256
}
265257
```
@@ -285,14 +277,46 @@ var sortedArrayToBST = function (nums) {
285277
return null;
286278
}
287279
const mid = (l + r) >> 1;
288-
const left = dfs(l, mid - 1);
289-
const right = dfs(mid + 1, r);
290-
return new TreeNode(nums[mid], left, right);
280+
return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r));
291281
};
292282
return dfs(0, nums.length - 1);
293283
};
294284
```
295285

286+
#### C#
287+
288+
```cs
289+
/**
290+
* Definition for a binary tree node.
291+
* public class TreeNode {
292+
* public int val;
293+
* public TreeNode left;
294+
* public TreeNode right;
295+
* public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
296+
* this.val = val;
297+
* this.left = left;
298+
* this.right = right;
299+
* }
300+
* }
301+
*/
302+
public class Solution {
303+
private int[] nums;
304+
305+
public TreeNode SortedArrayToBST(int[] nums) {
306+
this.nums = nums;
307+
return dfs(0, nums.Length - 1);
308+
}
309+
310+
private TreeNode dfs(int l, int r) {
311+
if (l > r) {
312+
return null;
313+
}
314+
int mid = (l + r) >> 1;
315+
return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r));
316+
}
317+
}
318+
```
319+
296320
<!-- tabs:end -->
297321

298322
<!-- solution:end -->

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

+72-48
Original file line numberDiff line numberDiff line change
@@ -57,19 +57,19 @@ tags:
5757

5858
### Solution 1: Binary Search + Recursion
5959

60-
We design a recursive function $dfs(l, r)$, which indicates that the node values of the current binary search tree to be constructed are all within the index range $[l, r]$ of the array `nums`. This function returns the root node of the constructed binary search tree.
60+
We design a recursive function $\textit{dfs}(l, r)$, which represents that the values of the nodes to be constructed in the current binary search tree are within the index range $[l, r]$ of the array $\textit{nums}$. This function returns the root node of the constructed binary search tree.
6161

62-
The execution process of the function $dfs(l, r)$ is as follows:
62+
The execution process of the function $\textit{dfs}(l, r)$ is as follows:
6363

64-
1. If $l > r$, it means the current array is empty, return `null`.
65-
2. If $l \leq r$, take the element with the index $mid = \lfloor \frac{l + r}{2} \rfloor$ in the array as the root node of the current binary search tree, where $\lfloor x \rfloor$ represents rounding down $x$.
66-
3. Recursively construct the left subtree of the current binary search tree, whose root node value is the element with the index $mid - 1$ in the array, and the node values of the left subtree are all within the index range $[l, mid - 1]$ of the array.
67-
4. Recursively construct the right subtree of the current binary search tree, whose root node value is the element with the index $mid + 1$ in the array, and the node values of the right subtree are all within the index range $[mid + 1, r]$ of the array.
64+
1. If $l > r$, it means the current array is empty, so return `null`.
65+
2. If $l \leq r$, take the element at index $\textit{mid} = \lfloor \frac{l + r}{2} \rfloor$ of the array as the root node of the current binary search tree, where $\lfloor x \rfloor$ denotes the floor function of $x$.
66+
3. Recursively construct the left subtree of the current binary search tree, with the root node's value being the element at index $\textit{mid} - 1$ of the array. The values of the nodes in the left subtree are within the index range $[l, \textit{mid} - 1]$ of the array.
67+
4. Recursively construct the right subtree of the current binary search tree, with the root node's value being the element at index $\textit{mid} + 1$ of the array. The values of the nodes in the right subtree are within the index range $[\textit{mid} + 1, r]$ of the array.
6868
5. Return the root node of the current binary search tree.
6969

70-
The answer is the return value of the function $dfs(0, n - 1)$.
70+
The answer is the return value of the function $\textit{dfs}(0, n - 1)$.
7171

72-
The time complexity is $O(n)$, and the space complexity is $O(\log n)$. Here, $n$ is the length of the array `nums`.
72+
The time complexity is $O(n)$, and the space complexity is $O(\log n)$. Here, $n$ is the length of the array $\textit{nums}$.
7373

7474
<!-- tabs:start -->
7575

@@ -84,13 +84,11 @@ The time complexity is $O(n)$, and the space complexity is $O(\log n)$. Here, $n
8484
# self.right = right
8585
class Solution:
8686
def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
87-
def dfs(l, r):
87+
def dfs(l: int, r: int) -> Optional[TreeNode]:
8888
if l > r:
8989
return None
9090
mid = (l + r) >> 1
91-
left = dfs(l, mid - 1)
92-
right = dfs(mid + 1, r)
93-
return TreeNode(nums[mid], left, right)
91+
return TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r))
9492

9593
return dfs(0, len(nums) - 1)
9694
```
@@ -126,9 +124,7 @@ class Solution {
126124
return null;
127125
}
128126
int mid = (l + r) >> 1;
129-
TreeNode left = dfs(l, mid - 1);
130-
TreeNode right = dfs(mid + 1, r);
131-
return new TreeNode(nums[mid], left, right);
127+
return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r));
132128
}
133129
}
134130
```
@@ -150,14 +146,12 @@ class Solution {
150146
class Solution {
151147
public:
152148
TreeNode* sortedArrayToBST(vector<int>& nums) {
153-
function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
149+
auto dfs = [&](this auto&& dfs, int l, int r) -> TreeNode* {
154150
if (l > r) {
155151
return nullptr;
156152
}
157153
int mid = (l + r) >> 1;
158-
auto left = dfs(l, mid - 1);
159-
auto right = dfs(mid + 1, r);
160-
return new TreeNode(nums[mid], left, right);
154+
return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r));
161155
};
162156
return dfs(0, nums.size() - 1);
163157
}
@@ -182,8 +176,7 @@ func sortedArrayToBST(nums []int) *TreeNode {
182176
return nil
183177
}
184178
mid := (l + r) >> 1
185-
left, right := dfs(l, mid-1), dfs(mid+1, r)
186-
return &TreeNode{nums[mid], left, right}
179+
return &TreeNode{nums[mid], dfs(l, mid-1), dfs(mid+1, r)}
187180
}
188181
return dfs(0, len(nums)-1)
189182
}
@@ -207,16 +200,14 @@ func sortedArrayToBST(nums []int) *TreeNode {
207200
*/
208201

209202
function sortedArrayToBST(nums: number[]): TreeNode | null {
210-
const n = nums.length;
211-
if (n === 0) {
212-
return null;
213-
}
214-
const mid = n >> 1;
215-
return new TreeNode(
216-
nums[mid],
217-
sortedArrayToBST(nums.slice(0, mid)),
218-
sortedArrayToBST(nums.slice(mid + 1)),
219-
);
203+
const dfs = (l: number, r: number): TreeNode | null => {
204+
if (l > r) {
205+
return null;
206+
}
207+
const mid = (l + r) >> 1;
208+
return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r));
209+
};
210+
return dfs(0, nums.length - 1);
220211
}
221212
```
222213

@@ -241,23 +232,24 @@ function sortedArrayToBST(nums: number[]): TreeNode | null {
241232
// }
242233
// }
243234
// }
244-
use std::cell::RefCell;
245235
use std::rc::Rc;
236+
use std::cell::RefCell;
246237
impl Solution {
247-
fn to_bst(nums: &Vec<i32>, start: usize, end: usize) -> Option<Rc<RefCell<TreeNode>>> {
248-
if start >= end {
249-
return None;
250-
}
251-
let mid = start + (end - start) / 2;
252-
Some(Rc::new(RefCell::new(TreeNode {
253-
val: nums[mid],
254-
left: Self::to_bst(nums, start, mid),
255-
right: Self::to_bst(nums, mid + 1, end),
256-
})))
257-
}
258-
259238
pub fn sorted_array_to_bst(nums: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
260-
Self::to_bst(&nums, 0, nums.len())
239+
fn dfs(nums: &Vec<i32>, l: usize, r: usize) -> Option<Rc<RefCell<TreeNode>>> {
240+
if l > r {
241+
return None;
242+
}
243+
let mid = (l + r) / 2;
244+
if mid >= nums.len() {
245+
return None;
246+
}
247+
let mut node = Rc::new(RefCell::new(TreeNode::new(nums[mid])));
248+
node.borrow_mut().left = dfs(nums, l, mid - 1);
249+
node.borrow_mut().right = dfs(nums, mid + 1, r);
250+
Some(node)
251+
}
252+
dfs(&nums, 0, nums.len() - 1)
261253
}
262254
}
263255
```
@@ -283,14 +275,46 @@ var sortedArrayToBST = function (nums) {
283275
return null;
284276
}
285277
const mid = (l + r) >> 1;
286-
const left = dfs(l, mid - 1);
287-
const right = dfs(mid + 1, r);
288-
return new TreeNode(nums[mid], left, right);
278+
return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r));
289279
};
290280
return dfs(0, nums.length - 1);
291281
};
292282
```
293283

284+
#### C#
285+
286+
```cs
287+
/**
288+
* Definition for a binary tree node.
289+
* public class TreeNode {
290+
* public int val;
291+
* public TreeNode left;
292+
* public TreeNode right;
293+
* public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
294+
* this.val = val;
295+
* this.left = left;
296+
* this.right = right;
297+
* }
298+
* }
299+
*/
300+
public class Solution {
301+
private int[] nums;
302+
303+
public TreeNode SortedArrayToBST(int[] nums) {
304+
this.nums = nums;
305+
return dfs(0, nums.Length - 1);
306+
}
307+
308+
private TreeNode dfs(int l, int r) {
309+
if (l > r) {
310+
return null;
311+
}
312+
int mid = (l + r) >> 1;
313+
return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r));
314+
}
315+
}
316+
```
317+
294318
<!-- tabs:end -->
295319

296320
<!-- solution:end -->

0 commit comments

Comments
 (0)