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 57e0f6c

Browse files
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‎

Lines changed: 104 additions & 0 deletions
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‎

Lines changed: 104 additions & 0 deletions
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
```
Lines changed: 53 additions & 0 deletions
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+
}
Lines changed: 41 additions & 0 deletions
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)

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