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 50ce67e

Browse files
feat: add solutions to lc problem: No.0109 (doocs#4161)
No.0109.Convert Sorted List to Binary Search Tree
1 parent afd76a0 commit 50ce67e

File tree

10 files changed

+349
-345
lines changed

10 files changed

+349
-345
lines changed

‎solution/0100-0199/0109.Convert Sorted List to Binary Search Tree/README.md‎

Lines changed: 118 additions & 114 deletions
Original file line numberDiff line numberDiff line change
@@ -56,7 +56,15 @@ tags:
5656

5757
<!-- solution:start -->
5858

59-
### 方法一
59+
### 方法一:DFS
60+
61+
我们先将链表转换为数组 $\textit{nums},ドル然后使用深度优先搜索构造二叉搜索树。
62+
63+
我们定义一个函数 $\textit{dfs}(i, j),ドル其中 $i$ 和 $j$ 表示当前区间为 $[i, j]$。每次我们选择区间中间位置 $\textit{mid}$ 的数字作为根节点,递归地构造左侧区间 $[i, \textit{mid} - 1]$ 的子树,以及右侧区间 $[\textit{mid} + 1, j]$ 的子树。最后返回 $\textit{mid}$ 对应的节点作为当前子树的根节点。
64+
65+
在主函数中,我们只需要调用 $\textit{dfs}(0, n - 1)$ 并返回即可。
66+
67+
时间复杂度 $O(n),ドル空间复杂度 $O(n)$。其中 $n$ 是链表的长度。
6068

6169
<!-- tabs:start -->
6270

@@ -75,20 +83,19 @@ tags:
7583
# self.left = left
7684
# self.right = right
7785
class Solution:
78-
def sortedListToBST(self, head: ListNode) -> TreeNode:
79-
def buildBST(nums, start, end):
80-
if start > end:
86+
def sortedListToBST(self, head: Optional[ListNode]) -> Optional[TreeNode]:
87+
def dfs(i: int, j: int) -> Optional[TreeNode]:
88+
if i > j:
8189
return None
82-
mid = (start + end) >> 1
83-
return TreeNode(
84-
nums[mid], buildBST(nums, start, mid - 1), buildBST(nums, mid + 1, end)
85-
)
90+
mid = (i + j) >> 1
91+
l, r = dfs(i, mid - 1), dfs(mid + 1, j)
92+
return TreeNode(nums[mid], l, r)
8693

8794
nums = []
8895
while head:
8996
nums.append(head.val)
9097
head = head.next
91-
return buildBST(nums, 0, len(nums) - 1)
98+
return dfs(0, len(nums) - 1)
9299
```
93100

94101
#### Java
@@ -120,23 +127,23 @@ class Solution:
120127
* }
121128
*/
122129
class Solution {
130+
private List<Integer> nums = new ArrayList<>();
131+
123132
public TreeNode sortedListToBST(ListNode head) {
124-
List<Integer> nums = new ArrayList<>();
125133
for (; head != null; head = head.next) {
126134
nums.add(head.val);
127135
}
128-
return buildBST(nums, 0, nums.size() - 1);
136+
return dfs(0, nums.size() - 1);
129137
}
130138

131-
private TreeNode buildBST(List<Integer>nums, int start, int end) {
132-
if (start > end) {
139+
private TreeNode dfs(int i, int j) {
140+
if (i > j) {
133141
return null;
134142
}
135-
int mid = (start + end) >> 1;
136-
TreeNode root = new TreeNode(nums.get(mid));
137-
root.left = buildBST(nums, start, mid - 1);
138-
root.right = buildBST(nums, mid + 1, end);
139-
return root;
143+
int mid = (i + j) >> 1;
144+
TreeNode left = dfs(i, mid - 1);
145+
TreeNode right = dfs(mid + 1, j);
146+
return new TreeNode(nums.get(mid), left, right);
140147
}
141148
}
142149
```
@@ -169,22 +176,19 @@ class Solution {
169176
public:
170177
TreeNode* sortedListToBST(ListNode* head) {
171178
vector<int> nums;
172-
for (; head != nullptr; head = head->next) {
179+
for (; head; head = head->next) {
173180
nums.push_back(head->val);
174181
}
175-
return buildBST(nums, 0, nums.size() - 1);
176-
}
177-
178-
private:
179-
TreeNode* buildBST(vector<int>& nums, int start, int end) {
180-
if (start > end) {
181-
return nullptr;
182-
}
183-
int mid = (start + end) / 2;
184-
TreeNode* root = new TreeNode(nums[mid]);
185-
root->left = buildBST(nums, start, mid - 1);
186-
root->right = buildBST(nums, mid + 1, end);
187-
return root;
182+
auto dfs = [&](this auto&& dfs, int i, int j) -> TreeNode* {
183+
if (i > j) {
184+
return nullptr;
185+
}
186+
int mid = (i + j) >> 1;
187+
TreeNode* left = dfs(i, mid - 1);
188+
TreeNode* right = dfs(mid + 1, j);
189+
return new TreeNode(nums[mid], left, right);
190+
};
191+
return dfs(0, nums.size() - 1);
188192
}
189193
};
190194
```
@@ -209,23 +213,20 @@ private:
209213
*/
210214
func sortedListToBST(head *ListNode) *TreeNode {
211215
nums := []int{}
212-
for head != nil {
216+
for ; head != nil; head = head.Next {
213217
nums = append(nums, head.Val)
214-
head = head.Next
215-
}
216-
return buildBST(nums, 0, len(nums)-1)
217-
}
218-
219-
func buildBST(nums []int, start, end int) *TreeNode {
220-
if start > end {
221-
return nil
222218
}
223-
mid := (start + end) >> 1
224-
return &TreeNode{
225-
Val: nums[mid],
226-
Left: buildBST(nums, start, mid-1),
227-
Right: buildBST(nums, mid+1, end),
219+
var dfs func(i, j int) *TreeNode
220+
dfs = func(i, j int) *TreeNode {
221+
if i > j {
222+
return nil
223+
}
224+
mid := (i + j) >> 1
225+
left := dfs(i, mid-1)
226+
right := dfs(mid+1, j)
227+
return &TreeNode{nums[mid], left, right}
228228
}
229+
return dfs(0, len(nums)-1)
229230
}
230231
```
231232

@@ -258,26 +259,21 @@ func buildBST(nums []int, start, end int) *TreeNode {
258259
* }
259260
*/
260261

261-
const find = (start: ListNode | null, end: ListNode | null) => {
262-
let fast = start;
263-
let slow = start;
264-
while (fast !== end && fast.next !== end) {
265-
fast = fast.next.next;
266-
slow = slow.next;
267-
}
268-
return slow;
269-
};
270-
271-
const build = (start: ListNode | null, end: ListNode | null) => {
272-
if (start == end) {
273-
return null;
274-
}
275-
const node = find(start, end);
276-
return new TreeNode(node.val, build(start, node), build(node.next, end));
277-
};
278-
279262
function sortedListToBST(head: ListNode | null): TreeNode | null {
280-
return build(head, null);
263+
const nums: number[] = [];
264+
for (; head; head = head.next) {
265+
nums.push(head.val);
266+
}
267+
const dfs = (i: number, j: number): TreeNode | null => {
268+
if (i > j) {
269+
return null;
270+
}
271+
const mid = (i + j) >> 1;
272+
const left = dfs(i, mid - 1);
273+
const right = dfs(mid + 1, j);
274+
return new TreeNode(nums[mid], left, right);
275+
};
276+
return dfs(0, nums.length - 1);
281277
}
282278
```
283279

@@ -320,27 +316,29 @@ function sortedListToBST(head: ListNode | null): TreeNode | null {
320316
// }
321317
use std::cell::RefCell;
322318
use std::rc::Rc;
319+
323320
impl Solution {
324-
fn build(vals: &Vec<i32>, start: usize, end: usize) -> Option<Rc<RefCell<TreeNode>>> {
325-
if start == end {
326-
return None;
321+
pub fn sorted_list_to_bst(head: Option<Box<ListNode>>) -> Option<Rc<RefCell<TreeNode>>> {
322+
let mut nums = Vec::new();
323+
let mut current = head;
324+
while let Some(node) = current {
325+
nums.push(node.val);
326+
current = node.next;
327327
}
328-
let mid = (start + end) >> 1;
329-
Some(Rc::new(RefCell::new(TreeNode {
330-
val: vals[mid],
331-
left: Self::build(vals, start, mid),
332-
right: Self::build(vals, mid + 1, end),
333-
})))
334-
}
335328

336-
pub fn sorted_list_to_bst(head: Option<Box<ListNode>>) -> Option<Rc<RefCell<TreeNode>>> {
337-
let mut vals = Vec::new();
338-
let mut cur = &head;
339-
while let Some(node) = cur {
340-
vals.push(node.val);
341-
cur = &node.next;
329+
fn dfs(nums: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
330+
if nums.is_empty() {
331+
return None;
332+
}
333+
let mid = nums.len() / 2;
334+
Some(Rc::new(RefCell::new(TreeNode {
335+
val: nums[mid],
336+
left: dfs(&nums[..mid]),
337+
right: dfs(&nums[mid + 1..]),
338+
})))
342339
}
343-
Self::build(&vals, 0, vals.len())
340+
341+
dfs(&nums)
344342
}
345343
}
346344
```
@@ -368,22 +366,20 @@ impl Solution {
368366
* @return {TreeNode}
369367
*/
370368
var sortedListToBST = function (head) {
371-
const buildBST = (nums, start, end) => {
372-
if (start > end) {
369+
const nums = [];
370+
for (; head; head = head.next) {
371+
nums.push(head.val);
372+
}
373+
const dfs = (i, j) => {
374+
if (i > j) {
373375
return null;
374376
}
375-
const mid = (start + end) >> 1;
376-
const root = new TreeNode(nums[mid]);
377-
root.left = buildBST(nums, start, mid - 1);
378-
root.right = buildBST(nums, mid + 1, end);
379-
return root;
377+
const mid = (i + j) >> 1;
378+
const left = dfs(i, mid - 1);
379+
const right = dfs(mid + 1, j);
380+
return new TreeNode(nums[mid], left, right);
380381
};
381-
382-
const nums = new Array();
383-
for (; head != null; head = head.next) {
384-
nums.push(head.val);
385-
}
386-
return buildBST(nums, 0, nums.length - 1);
382+
return dfs(0, nums.length - 1);
387383
};
388384
```
389385

@@ -405,30 +401,38 @@ var sortedListToBST = function (head) {
405401
* struct TreeNode *right;
406402
* };
407403
*/
408-
struct ListNode* find(struct ListNode* start, struct ListNode* end) {
409-
struct ListNode* fast = start;
410-
struct ListNode* slow = start;
411-
while (fast != end && fast->next != end) {
412-
fast = fast->next->next;
413-
slow = slow->next;
414-
}
415-
return slow;
416-
}
417-
418-
struct TreeNode* bulid(struct ListNode* start, struct ListNode* end) {
419-
if (start == end) {
404+
struct TreeNode* dfs(int* nums, int i, int j) {
405+
if (i > j) {
420406
return NULL;
421407
}
422-
struct ListNode* node = find(start, end);
423-
struct TreeNode* ans = malloc(sizeof(struct TreeNode));
424-
ans->val = node->val;
425-
ans->left = bulid(start, node);
426-
ans->right = bulid(node->next, end);
427-
return ans;
408+
int mid = (i + j) >> 1;
409+
struct TreeNode* left = dfs(nums, i, mid - 1);
410+
struct TreeNode* right = dfs(nums, mid + 1, j);
411+
struct TreeNode* root = (struct TreeNode*) malloc(sizeof(struct TreeNode));
412+
root->val = nums[mid];
413+
root->left = left;
414+
root->right = right;
415+
return root;
428416
}
429417

430418
struct TreeNode* sortedListToBST(struct ListNode* head) {
431-
return bulid(head, NULL);
419+
int size = 0;
420+
struct ListNode* temp = head;
421+
while (temp) {
422+
size++;
423+
temp = temp->next;
424+
}
425+
426+
int* nums = (int*) malloc(size * sizeof(int));
427+
temp = head;
428+
for (int i = 0; i < size; i++) {
429+
nums[i] = temp->val;
430+
temp = temp->next;
431+
}
432+
433+
struct TreeNode* root = dfs(nums, 0, size - 1);
434+
free(nums);
435+
return root;
432436
}
433437
```
434438

0 commit comments

Comments
(0)

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