Skip to content

Commit 57e0f6c

Browse files
YangFongYangFong
committed
feat: add solutions to lc problems: No.1008,1019
- No.1008.Construct Binary Search Tree from Preorder Traversal - No.1019.Next Greater Node In Linked List
1 parent db8d391 commit 57e0f6c

File tree

8 files changed

+559
-0
lines changed

8 files changed

+559
-0
lines changed

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

+104
Original file line numberDiff line numberDiff line change
@@ -203,6 +203,110 @@ func bstFromPreorder(preorder []int) *TreeNode {
203203
}
204204
```
205205

206+
### **TypeScript**
207+
208+
```ts
209+
/**
210+
* Definition for a binary tree node.
211+
* class TreeNode {
212+
* val: number
213+
* left: TreeNode | null
214+
* right: TreeNode | null
215+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
216+
* this.val = (val===undefined ? 0 : val)
217+
* this.left = (left===undefined ? null : left)
218+
* this.right = (right===undefined ? null : right)
219+
* }
220+
* }
221+
*/
222+
223+
function bstFromPreorder(preorder: number[]): TreeNode | null {
224+
const n = preorder.length;
225+
const next = new Array(n);
226+
const stack = [];
227+
for (let i = n - 1; i >= 0; i--) {
228+
while (
229+
stack.length !== 0 &&
230+
preorder[stack[stack.length - 1]] < preorder[i]
231+
) {
232+
stack.pop();
233+
}
234+
next[i] = stack[stack.length - 1] ?? n;
235+
stack.push(i);
236+
}
237+
238+
const dfs = (left: number, right: number) => {
239+
if (left >= right) {
240+
return null;
241+
}
242+
return new TreeNode(
243+
preorder[left],
244+
dfs(left + 1, next[left]),
245+
dfs(next[left], right),
246+
);
247+
};
248+
return dfs(0, n);
249+
}
250+
```
251+
252+
### **Rust**
253+
254+
```rust
255+
// Definition for a binary tree node.
256+
// #[derive(Debug, PartialEq, Eq)]
257+
// pub struct TreeNode {
258+
// pub val: i32,
259+
// pub left: Option<Rc<RefCell<TreeNode>>>,
260+
// pub right: Option<Rc<RefCell<TreeNode>>>,
261+
// }
262+
//
263+
// impl TreeNode {
264+
// #[inline]
265+
// pub fn new(val: i32) -> Self {
266+
// TreeNode {
267+
// val,
268+
// left: None,
269+
// right: None
270+
// }
271+
// }
272+
// }
273+
use std::rc::Rc;
274+
use std::cell::RefCell;
275+
impl Solution {
276+
fn dfs(
277+
preorder: &Vec<i32>,
278+
next: &Vec<usize>,
279+
left: usize,
280+
right: usize,
281+
) -> Option<Rc<RefCell<TreeNode>>> {
282+
if left >= right {
283+
return None;
284+
}
285+
Some(Rc::new(RefCell::new(TreeNode {
286+
val: preorder[left],
287+
left: Self::dfs(preorder, next, left + 1, next[left]),
288+
right: Self::dfs(preorder, next, next[left], right),
289+
})))
290+
}
291+
292+
pub fn bst_from_preorder(preorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
293+
let n = preorder.len();
294+
let mut stack = Vec::new();
295+
let mut next = vec![n; n];
296+
for i in (0..n).rev() {
297+
while !stack.is_empty() && preorder[*stack.last().unwrap()] < preorder[i] {
298+
stack.pop();
299+
}
300+
if !stack.is_empty() {
301+
next[i] = *stack.last().unwrap();
302+
}
303+
stack.push(i);
304+
}
305+
Self::dfs(&preorder, &next, 0, n)
306+
}
307+
}
308+
```
309+
206310
### **...**
207311

208312
```

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

+104
Original file line numberDiff line numberDiff line change
@@ -187,6 +187,110 @@ func bstFromPreorder(preorder []int) *TreeNode {
187187
}
188188
```
189189

190+
### **TypeScript**
191+
192+
```ts
193+
/**
194+
* Definition for a binary tree node.
195+
* class TreeNode {
196+
* val: number
197+
* left: TreeNode | null
198+
* right: TreeNode | null
199+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
200+
* this.val = (val===undefined ? 0 : val)
201+
* this.left = (left===undefined ? null : left)
202+
* this.right = (right===undefined ? null : right)
203+
* }
204+
* }
205+
*/
206+
207+
function bstFromPreorder(preorder: number[]): TreeNode | null {
208+
const n = preorder.length;
209+
const next = new Array(n);
210+
const stack = [];
211+
for (let i = n - 1; i >= 0; i--) {
212+
while (
213+
stack.length !== 0 &&
214+
preorder[stack[stack.length - 1]] < preorder[i]
215+
) {
216+
stack.pop();
217+
}
218+
next[i] = stack[stack.length - 1] ?? n;
219+
stack.push(i);
220+
}
221+
222+
const dfs = (left: number, right: number) => {
223+
if (left >= right) {
224+
return null;
225+
}
226+
return new TreeNode(
227+
preorder[left],
228+
dfs(left + 1, next[left]),
229+
dfs(next[left], right),
230+
);
231+
};
232+
return dfs(0, n);
233+
}
234+
```
235+
236+
### **Rust**
237+
238+
```rust
239+
// Definition for a binary tree node.
240+
// #[derive(Debug, PartialEq, Eq)]
241+
// pub struct TreeNode {
242+
// pub val: i32,
243+
// pub left: Option<Rc<RefCell<TreeNode>>>,
244+
// pub right: Option<Rc<RefCell<TreeNode>>>,
245+
// }
246+
//
247+
// impl TreeNode {
248+
// #[inline]
249+
// pub fn new(val: i32) -> Self {
250+
// TreeNode {
251+
// val,
252+
// left: None,
253+
// right: None
254+
// }
255+
// }
256+
// }
257+
use std::rc::Rc;
258+
use std::cell::RefCell;
259+
impl Solution {
260+
fn dfs(
261+
preorder: &Vec<i32>,
262+
next: &Vec<usize>,
263+
left: usize,
264+
right: usize,
265+
) -> Option<Rc<RefCell<TreeNode>>> {
266+
if left >= right {
267+
return None;
268+
}
269+
Some(Rc::new(RefCell::new(TreeNode {
270+
val: preorder[left],
271+
left: Self::dfs(preorder, next, left + 1, next[left]),
272+
right: Self::dfs(preorder, next, next[left], right),
273+
})))
274+
}
275+
276+
pub fn bst_from_preorder(preorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
277+
let n = preorder.len();
278+
let mut stack = Vec::new();
279+
let mut next = vec![n; n];
280+
for i in (0..n).rev() {
281+
while !stack.is_empty() && preorder[*stack.last().unwrap()] < preorder[i] {
282+
stack.pop();
283+
}
284+
if !stack.is_empty() {
285+
next[i] = *stack.last().unwrap();
286+
}
287+
stack.push(i);
288+
}
289+
Self::dfs(&preorder, &next, 0, n)
290+
}
291+
}
292+
```
293+
190294
### **...**
191295

192296
```

‎solution/1000-1099/1008.Construct Binary Search Tree from Preorder Traversal/Solution.rs

+53
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,53 @@
1+
// Definition for a binary tree node.
2+
// #[derive(Debug, PartialEq, Eq)]
3+
// pub struct TreeNode {
4+
// pub val: i32,
5+
// pub left: Option<Rc<RefCell<TreeNode>>>,
6+
// pub right: Option<Rc<RefCell<TreeNode>>>,
7+
// }
8+
//
9+
// impl TreeNode {
10+
// #[inline]
11+
// pub fn new(val: i32) -> Self {
12+
// TreeNode {
13+
// val,
14+
// left: None,
15+
// right: None
16+
// }
17+
// }
18+
// }
19+
use std::rc::Rc;
20+
use std::cell::RefCell;
21+
impl Solution {
22+
fn dfs(
23+
preorder: &Vec<i32>,
24+
next: &Vec<usize>,
25+
left: usize,
26+
right: usize,
27+
) -> Option<Rc<RefCell<TreeNode>>> {
28+
if left >= right {
29+
return None;
30+
}
31+
Some(Rc::new(RefCell::new(TreeNode {
32+
val: preorder[left],
33+
left: Self::dfs(preorder, next, left + 1, next[left]),
34+
right: Self::dfs(preorder, next, next[left], right),
35+
})))
36+
}
37+
38+
pub fn bst_from_preorder(preorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
39+
let n = preorder.len();
40+
let mut stack = Vec::new();
41+
let mut next = vec![n; n];
42+
for i in (0..n).rev() {
43+
while !stack.is_empty() && preorder[*stack.last().unwrap()] < preorder[i] {
44+
stack.pop();
45+
}
46+
if !stack.is_empty() {
47+
next[i] = *stack.last().unwrap();
48+
}
49+
stack.push(i);
50+
}
51+
Self::dfs(&preorder, &next, 0, n)
52+
}
53+
}

‎solution/1000-1099/1008.Construct Binary Search Tree from Preorder Traversal/Solution.ts

+41
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,41 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* class TreeNode {
4+
* val: number
5+
* left: TreeNode | null
6+
* right: TreeNode | null
7+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
8+
* this.val = (val===undefined ? 0 : val)
9+
* this.left = (left===undefined ? null : left)
10+
* this.right = (right===undefined ? null : right)
11+
* }
12+
* }
13+
*/
14+
15+
function bstFromPreorder(preorder: number[]): TreeNode | null {
16+
const n = preorder.length;
17+
const next = new Array(n);
18+
const stack = [];
19+
for (let i = n - 1; i >= 0; i--) {
20+
while (
21+
stack.length !== 0 &&
22+
preorder[stack[stack.length - 1]] < preorder[i]
23+
) {
24+
stack.pop();
25+
}
26+
next[i] = stack[stack.length - 1] ?? n;
27+
stack.push(i);
28+
}
29+
30+
const dfs = (left: number, right: number) => {
31+
if (left >= right) {
32+
return null;
33+
}
34+
return new TreeNode(
35+
preorder[left],
36+
dfs(left + 1, next[left]),
37+
dfs(next[left], right),
38+
);
39+
};
40+
return dfs(0, n);
41+
}

0 commit comments

Comments
 (0)