Skip to content

Commit 62d5f6e

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lcci problem: No.04.02
No.04.02.Minimum Height Tree
1 parent e84c011 commit 62d5f6e

File tree

6 files changed

+329
-2
lines changed

6 files changed

+329
-2
lines changed

‎lcci/04.02.Minimum Height Tree/README.md

+114-1
Original file line numberDiff line numberDiff line change
@@ -11,22 +11,135 @@
1111

1212
<!-- 这里可写通用的实现逻辑 -->
1313

14+
先找到数组的中间点，作为二叉搜索树的根节点，然后递归左右子树即可。
15+
1416
<!-- tabs:start -->
1517

1618
### **Python3**
1719

1820
<!-- 这里可写当前语言的特殊实现逻辑 -->
1921

2022
```python
21-
23+
# Definition for a binary tree node.
24+
# class TreeNode:
25+
# def __init__(self, x):
26+
# self.val = x
27+
# self.left = None
28+
# self.right = None
29+
30+
class Solution:
31+
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
32+
def dfs(i, j):
33+
if i > j:
34+
return None
35+
if i == j:
36+
return TreeNode(nums[i])
37+
mid = (i + j) >> 1
38+
node = TreeNode(nums[mid])
39+
node.left = dfs(i, mid - 1)
40+
node.right = dfs(mid + 1, j)
41+
return node
42+
43+
return dfs(0, len(nums) - 1)
2244
```
2345

2446
### **Java**
2547

2648
<!-- 这里可写当前语言的特殊实现逻辑 -->
2749

2850
```java
51+
/**
52+
* Definition for a binary tree node.
53+
* public class TreeNode {
54+
* int val;
55+
* TreeNode left;
56+
* TreeNode right;
57+
* TreeNode(int x) { val = x; }
58+
* }
59+
*/
60+
class Solution {
61+
private int[] nums;
62+
63+
public TreeNode sortedArrayToBST(int[] nums) {
64+
this.nums = nums;
65+
return dfs(0, nums.length - 1);
66+
}
67+
68+
private TreeNode dfs(int i, int j) {
69+
if (i > j) {
70+
return null;
71+
}
72+
if (i == j) {
73+
return new TreeNode(nums[i]);
74+
}
75+
int mid = (i + j) >>> 1;
76+
TreeNode node = new TreeNode(nums[mid]);
77+
node.left = dfs(i, mid - 1);
78+
node.right = dfs(mid + 1, j);
79+
return node;
80+
}
81+
}
82+
```
83+
84+
### **C++**
85+
86+
```cpp
87+
/**
88+
* Definition for a binary tree node.
89+
* struct TreeNode {
90+
* int val;
91+
* TreeNode *left;
92+
* TreeNode *right;
93+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
94+
* };
95+
*/
96+
class Solution {
97+
public:
98+
vector<int> nums;
99+
100+
TreeNode* sortedArrayToBST(vector<int>& nums) {
101+
this->nums = nums;
102+
return dfs(0, nums.size() - 1);
103+
}
104+
105+
TreeNode* dfs(int i, int j) {
106+
if (i > j) return nullptr;
107+
if (i == j) return new TreeNode(nums[i]);
108+
int mid = i + j >> 1;
109+
TreeNode* node = new TreeNode(nums[mid]);
110+
node->left = dfs(i, mid - 1);
111+
node->right = dfs(mid + 1, j);
112+
return node;
113+
}
114+
};
115+
```
29116
117+
### **Go**
118+
119+
```go
120+
/**
121+
* Definition for a binary tree node.
122+
* type TreeNode struct {
123+
* Val int
124+
* Left *TreeNode
125+
* Right *TreeNode
126+
* }
127+
*/
128+
func sortedArrayToBST(nums []int) *TreeNode {
129+
var dfs func(i, j int) *TreeNode
130+
dfs = func(i, j int) *TreeNode {
131+
if i > j {
132+
return nil
133+
}
134+
if i == j {
135+
return &TreeNode{Val: nums[i]}
136+
}
137+
mid := (i + j) >> 1
138+
return &TreeNode{Val: nums[mid], Left: dfs(i, mid-1), Right: dfs(mid+1, j)}
139+
}
140+
141+
return dfs(0, len(nums)-1)
142+
}
30143
```
31144

32145
### **...**

‎lcci/04.02.Minimum Height Tree/README_EN.md

+112-1
Original file line numberDiff line numberDiff line change
@@ -37,13 +37,124 @@ One possible answer is: [0,-3,9,-10,null,5]，which represents the following tre
3737
### **Python3**
3838

3939
```python
40-
40+
# Definition for a binary tree node.
41+
# class TreeNode:
42+
# def __init__(self, x):
43+
# self.val = x
44+
# self.left = None
45+
# self.right = None
46+
47+
class Solution:
48+
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
49+
def dfs(i, j):
50+
if i > j:
51+
return None
52+
if i == j:
53+
return TreeNode(nums[i])
54+
mid = (i + j) >> 1
55+
node = TreeNode(nums[mid])
56+
node.left = dfs(i, mid - 1)
57+
node.right = dfs(mid + 1, j)
58+
return node
59+
60+
return dfs(0, len(nums) - 1)
4161
```
4262

4363
### **Java**
4464

4565
```java
66+
/**
67+
* Definition for a binary tree node.
68+
* public class TreeNode {
69+
* int val;
70+
* TreeNode left;
71+
* TreeNode right;
72+
* TreeNode(int x) { val = x; }
73+
* }
74+
*/
75+
class Solution {
76+
private int[] nums;
77+
78+
public TreeNode sortedArrayToBST(int[] nums) {
79+
this.nums = nums;
80+
return dfs(0, nums.length - 1);
81+
}
82+
83+
private TreeNode dfs(int i, int j) {
84+
if (i > j) {
85+
return null;
86+
}
87+
if (i == j) {
88+
return new TreeNode(nums[i]);
89+
}
90+
int mid = (i + j) >>> 1;
91+
TreeNode node = new TreeNode(nums[mid]);
92+
node.left = dfs(i, mid - 1);
93+
node.right = dfs(mid + 1, j);
94+
return node;
95+
}
96+
}
97+
```
98+
99+
### **C++**
100+
101+
```cpp
102+
/**
103+
* Definition for a binary tree node.
104+
* struct TreeNode {
105+
* int val;
106+
* TreeNode *left;
107+
* TreeNode *right;
108+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
109+
* };
110+
*/
111+
class Solution {
112+
public:
113+
vector<int> nums;
114+
115+
TreeNode* sortedArrayToBST(vector<int>& nums) {
116+
this->nums = nums;
117+
return dfs(0, nums.size() - 1);
118+
}
119+
120+
TreeNode* dfs(int i, int j) {
121+
if (i > j) return nullptr;
122+
if (i == j) return new TreeNode(nums[i]);
123+
int mid = i + j >> 1;
124+
TreeNode* node = new TreeNode(nums[mid]);
125+
node->left = dfs(i, mid - 1);
126+
node->right = dfs(mid + 1, j);
127+
return node;
128+
}
129+
};
130+
```
46131
132+
### **Go**
133+
134+
```go
135+
/**
136+
* Definition for a binary tree node.
137+
* type TreeNode struct {
138+
* Val int
139+
* Left *TreeNode
140+
* Right *TreeNode
141+
* }
142+
*/
143+
func sortedArrayToBST(nums []int) *TreeNode {
144+
var dfs func(i, j int) *TreeNode
145+
dfs = func(i, j int) *TreeNode {
146+
if i > j {
147+
return nil
148+
}
149+
if i == j {
150+
return &TreeNode{Val: nums[i]}
151+
}
152+
mid := (i + j) >> 1
153+
return &TreeNode{Val: nums[mid], Left: dfs(i, mid-1), Right: dfs(mid+1, j)}
154+
}
155+
156+
return dfs(0, len(nums)-1)
157+
}
47158
```
48159

49160
### **...**

‎lcci/04.02.Minimum Height Tree/Solution.cpp

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
vector<int> nums;
13+
14+
TreeNode* sortedArrayToBST(vector<int>& nums) {
15+
this->nums = nums;
16+
return dfs(0, nums.size() - 1);
17+
}
18+
19+
TreeNode* dfs(int i, int j) {
20+
if (i > j) return nullptr;
21+
if (i == j) return new TreeNode(nums[i]);
22+
int mid = i + j >> 1;
23+
TreeNode* node = new TreeNode(nums[mid]);
24+
node->left = dfs(i, mid - 1);
25+
node->right = dfs(mid + 1, j);
26+
return node;
27+
}
28+
};

‎lcci/04.02.Minimum Height Tree/Solution.go

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
func sortedArrayToBST(nums []int) *TreeNode {
10+
var dfs func(i, j int) *TreeNode
11+
dfs = func(i, j int) *TreeNode {
12+
if i > j {
13+
return nil
14+
}
15+
if i == j {
16+
return &TreeNode{Val: nums[i]}
17+
}
18+
mid := (i + j) >> 1
19+
return &TreeNode{Val: nums[mid], Left: dfs(i, mid-1), Right: dfs(mid+1, j)}
20+
}
21+
22+
return dfs(0, len(nums)-1)
23+
}

‎lcci/04.02.Minimum Height Tree/Solution.java

+31
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* public class TreeNode {
4+
* int val;
5+
* TreeNode left;
6+
* TreeNode right;
7+
* TreeNode(int x) { val = x; }
8+
* }
9+
*/
10+
class Solution {
11+
private int[] nums;
12+
13+
public TreeNode sortedArrayToBST(int[] nums) {
14+
this.nums = nums;
15+
return dfs(0, nums.length - 1);
16+
}
17+
18+
private TreeNode dfs(int i, int j) {
19+
if (i > j) {
20+
return null;
21+
}
22+
if (i == j) {
23+
return new TreeNode(nums[i]);
24+
}
25+
int mid = (i + j) >>> 1;
26+
TreeNode node = new TreeNode(nums[mid]);
27+
node.left = dfs(i, mid - 1);
28+
node.right = dfs(mid + 1, j);
29+
return node;
30+
}
31+
}

‎lcci/04.02.Minimum Height Tree/Solution.py

+21
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, x):
4+
# self.val = x
5+
# self.left = None
6+
# self.right = None
7+
8+
class Solution:
9+
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
10+
def dfs(i, j):
11+
if i > j:
12+
return None
13+
if i == j:
14+
return TreeNode(nums[i])
15+
mid = (i + j) >> 1
16+
node = TreeNode(nums[mid])
17+
node.left = dfs(i, mid - 1)
18+
node.right = dfs(mid + 1, j)
19+
return node
20+
21+
return dfs(0, len(nums) - 1)

0 commit comments

Comments
 (0)