Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 836a3a6

Browse files
feat: add solutions to lc problem: No.0108 (doocs#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‎

Lines changed: 71 additions & 47 deletions
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‎

Lines changed: 72 additions & 48 deletions
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)

AltStyle によって変換されたページ (->オリジナル) /