Skip to content

Commit 02647f3

Browse files
yanglbmeyanglbme
committed
feat: add solutinos to lc problem: No.1008
No.1008.Construct Binary Search Tree from Preorder Traversal
1 parent 39fff1e commit 02647f3

File tree

21 files changed

+381
-72
lines changed

21 files changed

+381
-72
lines changed

‎solution/1000-1099/1000.Minimum Cost to Merge Stones/README.md

-1
Original file line numberDiff line numberDiff line change
@@ -83,4 +83,3 @@
8383
```
8484

8585
<!-- tabs:end -->
86-
<!-- tabs:end -->

‎solution/1000-1099/1000.Minimum Cost to Merge Stones/README_EN.md

-1
Original file line numberDiff line numberDiff line change
@@ -111,4 +111,3 @@ The total cost was 25, and this is the minimum possible.
111111
```
112112

113113
<!-- tabs:end -->
114-
<!-- tabs:end -->

‎solution/1000-1099/1001.Grid Illumination/README.md

-1
Original file line numberDiff line numberDiff line change
@@ -84,4 +84,3 @@
8484
```
8585

8686
<!-- tabs:end -->
87-
<!-- tabs:end -->

‎solution/1000-1099/1001.Grid Illumination/README_EN.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -76,5 +76,5 @@ The 1<sup>st</sup>&nbsp;query asks if the lamp at grid[1][0] is illuminated or n
7676
7777
```
7878

79-
<!-- tabs:end -->
80-
<!-- tabs:end -->
79+
80+
<!-- tabs:end -->

‎solution/1000-1099/1003.Check If Word Is Valid After Substitutions/README.md

+1-2
Original file line numberDiff line numberDiff line change
@@ -87,5 +87,4 @@
8787
8888
```
8989

90-
<!-- tabs:end -->
91-
<!-- tabs:end -->
90+
<!-- tabs:end -->

‎solution/1000-1099/1003.Check If Word Is Valid After Substitutions/README_EN.md

-1
Original file line numberDiff line numberDiff line change
@@ -81,4 +81,3 @@ Thus, &quot;abcabcababcc&quot; is valid.
8181
```
8282

8383
<!-- tabs:end -->
84-
<!-- tabs:end -->

‎solution/1000-1099/1006.Clumsy Factorial/README.md

-1
Original file line numberDiff line numberDiff line change
@@ -109,4 +109,3 @@ class Solution {
109109
```
110110

111111
<!-- tabs:end -->
112-
<!-- tabs:end -->

‎solution/1000-1099/1006.Clumsy Factorial/README_EN.md

+1-2
Original file line numberDiff line numberDiff line change
@@ -108,5 +108,4 @@ class Solution {
108108
109109
```
110110

111-
<!-- tabs:end -->
112-
<!-- tabs:end -->
111+
<!-- tabs:end -->

‎solution/1000-1099/1007.Minimum Domino Rotations For Equal Row/README.md

-1
Original file line numberDiff line numberDiff line change
@@ -73,4 +73,3 @@
7373
```
7474

7575
<!-- tabs:end -->
76-
<!-- tabs:end -->

‎solution/1000-1099/1007.Minimum Domino Rotations For Equal Row/README_EN.md

-1
Original file line numberDiff line numberDiff line change
@@ -63,4 +63,3 @@ In this case, it is not possible to rotate the dominoes to make one row of value
6363
```
6464

6565
<!-- tabs:end -->
66-
<!-- tabs:end -->

‎solution/1000-1099/1008.Construct Binary Search Tree from Preorder Traversal/README.md

+138-2
Original file line numberDiff line numberDiff line change
@@ -35,22 +35,159 @@
3535

3636
<!-- 这里可写通用的实现逻辑 -->
3737

38+
根据二叉搜索树的性质，DFS 构建即可。
39+
3840
<!-- tabs:start -->
3941

4042
### **Python3**
4143

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

4446
```python
45-
47+
# Definition for a binary tree node.
48+
# class TreeNode:
49+
# def __init__(self, val=0, left=None, right=None):
50+
# self.val = val
51+
# self.left = left
52+
# self.right = right
53+
class Solution:
54+
def bstFromPreorder(self, preorder: List[int]) -> Optional[TreeNode]:
55+
def dfs(preorder):
56+
if not preorder:
57+
return None
58+
root = TreeNode(preorder[0])
59+
left, right = 1, len(preorder)
60+
while left < right:
61+
mid = (left + right) >> 1
62+
if preorder[mid] > preorder[0]:
63+
right = mid
64+
else:
65+
left = mid + 1
66+
root.left = dfs(preorder[1:left])
67+
root.right = dfs(preorder[left:])
68+
return root
69+
70+
return dfs(preorder)
4671
```
4772

4873
### **Java**
4974

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

5277
```java
78+
/**
79+
* Definition for a binary tree node.
80+
* public class TreeNode {
81+
* int val;
82+
* TreeNode left;
83+
* TreeNode right;
84+
* TreeNode() {}
85+
* TreeNode(int val) { this.val = val; }
86+
* TreeNode(int val, TreeNode left, TreeNode right) {
87+
* this.val = val;
88+
* this.left = left;
89+
* this.right = right;
90+
* }
91+
* }
92+
*/
93+
class Solution {
94+
95+
public TreeNode bstFromPreorder(int[] preorder) {
96+
return dfs(preorder, 0, preorder.length - 1);
97+
}
98+
99+
private TreeNode dfs(int[] preorder, int i, int j) {
100+
if (i > j || i >= preorder.length) {
101+
return null;
102+
}
103+
TreeNode root = new TreeNode(preorder[i]);
104+
int left = i + 1, right = j + 1;
105+
while (left < right) {
106+
int mid = (left + right) >> 1;
107+
if (preorder[mid] > preorder[i]) {
108+
right = mid;
109+
} else {
110+
left = mid + 1;
111+
}
112+
}
113+
root.left = dfs(preorder, i + 1, left - 1);
114+
root.right = dfs(preorder, left, j);
115+
return root;
116+
}
117+
}
118+
119+
```
53120

121+
### **C++**
122+
123+
```cpp
124+
/**
125+
* Definition for a binary tree node.
126+
* struct TreeNode {
127+
* int val;
128+
* TreeNode *left;
129+
* TreeNode *right;
130+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
131+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
132+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
133+
* };
134+
*/
135+
class Solution {
136+
public:
137+
TreeNode* bstFromPreorder(vector<int>& preorder) {
138+
return dfs(preorder, 0, preorder.size() - 1);
139+
}
140+
141+
TreeNode* dfs(vector<int>& preorder, int i, int j) {
142+
if (i > j || i >= preorder.size()) return nullptr;
143+
TreeNode* root = new TreeNode(preorder[i]);
144+
int left = i + 1, right = j + 1;
145+
while (left < right)
146+
{
147+
int mid = (left + right) >> 1;
148+
if (preorder[mid] > preorder[i]) right = mid;
149+
else left = mid + 1;
150+
}
151+
root->left = dfs(preorder, i + 1, left - 1);
152+
root->right = dfs(preorder, left, j);
153+
return root;
154+
}
155+
};
156+
```
157+
158+
### **Go**
159+
160+
```go
161+
/**
162+
* Definition for a binary tree node.
163+
* type TreeNode struct {
164+
* Val int
165+
* Left *TreeNode
166+
* Right *TreeNode
167+
* }
168+
*/
169+
func bstFromPreorder(preorder []int) *TreeNode {
170+
var dfs func(i, j int) *TreeNode
171+
dfs = func(i, j int) *TreeNode {
172+
if i > j || i >= len(preorder) {
173+
return nil
174+
}
175+
root := &TreeNode{Val: preorder[i]}
176+
left, right := i+1, len(preorder)
177+
for left < right {
178+
mid := (left + right) >> 1
179+
if preorder[mid] > preorder[i] {
180+
right = mid
181+
} else {
182+
left = mid + 1
183+
}
184+
}
185+
root.Left = dfs(i+1, left-1)
186+
root.Right = dfs(left, j)
187+
return root
188+
}
189+
return dfs(0, len(preorder)-1)
190+
}
54191
```
55192

56193
### **...**
@@ -60,4 +197,3 @@
60197
```
61198

62199
<!-- tabs:end -->
63-
<!-- tabs:end -->

‎solution/1000-1099/1008.Construct Binary Search Tree from Preorder Traversal/README_EN.md

+136-2
Original file line numberDiff line numberDiff line change
@@ -43,13 +43,148 @@
4343
### **Python3**
4444

4545
```python
46-
46+
# Definition for a binary tree node.
47+
# class TreeNode:
48+
# def __init__(self, val=0, left=None, right=None):
49+
# self.val = val
50+
# self.left = left
51+
# self.right = right
52+
class Solution:
53+
def bstFromPreorder(self, preorder: List[int]) -> Optional[TreeNode]:
54+
def dfs(preorder):
55+
if not preorder:
56+
return None
57+
root = TreeNode(preorder[0])
58+
left, right = 1, len(preorder)
59+
while left < right:
60+
mid = (left + right) >> 1
61+
if preorder[mid] > preorder[0]:
62+
right = mid
63+
else:
64+
left = mid + 1
65+
root.left = dfs(preorder[1:left])
66+
root.right = dfs(preorder[left:])
67+
return root
68+
69+
return dfs(preorder)
4770
```
4871

4972
### **Java**
5073

5174
```java
75+
/**
76+
* Definition for a binary tree node.
77+
* public class TreeNode {
78+
* int val;
79+
* TreeNode left;
80+
* TreeNode right;
81+
* TreeNode() {}
82+
* TreeNode(int val) { this.val = val; }
83+
* TreeNode(int val, TreeNode left, TreeNode right) {
84+
* this.val = val;
85+
* this.left = left;
86+
* this.right = right;
87+
* }
88+
* }
89+
*/
90+
class Solution {
91+
92+
public TreeNode bstFromPreorder(int[] preorder) {
93+
return dfs(preorder, 0, preorder.length - 1);
94+
}
95+
96+
private TreeNode dfs(int[] preorder, int i, int j) {
97+
if (i > j || i >= preorder.length) {
98+
return null;
99+
}
100+
TreeNode root = new TreeNode(preorder[i]);
101+
int left = i + 1, right = j + 1;
102+
while (left < right) {
103+
int mid = (left + right) >> 1;
104+
if (preorder[mid] > preorder[i]) {
105+
right = mid;
106+
} else {
107+
left = mid + 1;
108+
}
109+
}
110+
root.left = dfs(preorder, i + 1, left - 1);
111+
root.right = dfs(preorder, left, j);
112+
return root;
113+
}
114+
}
115+
116+
```
52117

118+
### **C++**
119+
120+
```cpp
121+
/**
122+
* Definition for a binary tree node.
123+
* struct TreeNode {
124+
* int val;
125+
* TreeNode *left;
126+
* TreeNode *right;
127+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
128+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
129+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
130+
* };
131+
*/
132+
class Solution {
133+
public:
134+
TreeNode* bstFromPreorder(vector<int>& preorder) {
135+
return dfs(preorder, 0, preorder.size() - 1);
136+
}
137+
138+
TreeNode* dfs(vector<int>& preorder, int i, int j) {
139+
if (i > j || i >= preorder.size()) return nullptr;
140+
TreeNode* root = new TreeNode(preorder[i]);
141+
int left = i + 1, right = j + 1;
142+
while (left < right)
143+
{
144+
int mid = (left + right) >> 1;
145+
if (preorder[mid] > preorder[i]) right = mid;
146+
else left = mid + 1;
147+
}
148+
root->left = dfs(preorder, i + 1, left - 1);
149+
root->right = dfs(preorder, left, j);
150+
return root;
151+
}
152+
};
153+
```
154+
155+
### **Go**
156+
157+
```go
158+
/**
159+
* Definition for a binary tree node.
160+
* type TreeNode struct {
161+
* Val int
162+
* Left *TreeNode
163+
* Right *TreeNode
164+
* }
165+
*/
166+
func bstFromPreorder(preorder []int) *TreeNode {
167+
var dfs func(i, j int) *TreeNode
168+
dfs = func(i, j int) *TreeNode {
169+
if i > j || i >= len(preorder) {
170+
return nil
171+
}
172+
root := &TreeNode{Val: preorder[i]}
173+
left, right := i+1, len(preorder)
174+
for left < right {
175+
mid := (left + right) >> 1
176+
if preorder[mid] > preorder[i] {
177+
right = mid
178+
} else {
179+
left = mid + 1
180+
}
181+
}
182+
root.Left = dfs(i+1, left-1)
183+
root.Right = dfs(left, j)
184+
return root
185+
}
186+
return dfs(0, len(preorder)-1)
187+
}
53188
```
54189

55190
### **...**
@@ -59,4 +194,3 @@
59194
```
60195

61196
<!-- tabs:end -->
62-
<!-- tabs:end -->

0 commit comments

Comments
 (0)