Skip to content

Commit e67f8d6

Browse files
YangFongYangFong
committed
feat: add solutions to lc problems: No.0103,0105,0108
- No.0103.Binary Tree Zigzag Level Order Traversal - No.0105.Construct Binary Tree from Preorder and Inorder Traversal - No.0108.Convert Sorted Array to Binary Search Tree
1 parent 37f70c6 commit e67f8d6

File tree

12 files changed

+702
-0
lines changed

12 files changed

+702
-0
lines changed

‎solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md

+96
Original file line numberDiff line numberDiff line change
@@ -264,6 +264,102 @@ var zigzagLevelOrder = function (root) {
264264
};
265265
```
266266

267+
### **TypeScript**
268+
269+
```ts
270+
/**
271+
* Definition for a binary tree node.
272+
* class TreeNode {
273+
* val: number
274+
* left: TreeNode | null
275+
* right: TreeNode | null
276+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
277+
* this.val = (val===undefined ? 0 : val)
278+
* this.left = (left===undefined ? null : left)
279+
* this.right = (right===undefined ? null : right)
280+
* }
281+
* }
282+
*/
283+
284+
function zigzagLevelOrder(root: TreeNode | null): number[][] {
285+
const res = [];
286+
if (root == null) {
287+
return res;
288+
}
289+
let isDesc = false;
290+
const queue = [root];
291+
while (queue.length !== 0) {
292+
const arr = queue.slice().map(() => {
293+
const { val, left, right } = queue.shift();
294+
left && queue.push(left);
295+
right && queue.push(right);
296+
return val;
297+
});
298+
res.push(isDesc ? arr.reverse() : arr);
299+
isDesc = !isDesc;
300+
}
301+
return res;
302+
}
303+
```
304+
305+
### **Rust**
306+
307+
```rust
308+
// Definition for a binary tree node.
309+
// #[derive(Debug, PartialEq, Eq)]
310+
// pub struct TreeNode {
311+
// pub val: i32,
312+
// pub left: Option<Rc<RefCell<TreeNode>>>,
313+
// pub right: Option<Rc<RefCell<TreeNode>>>,
314+
// }
315+
//
316+
// impl TreeNode {
317+
// #[inline]
318+
// pub fn new(val: i32) -> Self {
319+
// TreeNode {
320+
// val,
321+
// left: None,
322+
// right: None
323+
// }
324+
// }
325+
// }
326+
use std::rc::Rc;
327+
use std::cell::RefCell;
328+
use std::collections::VecDeque;
329+
impl Solution {
330+
pub fn zigzag_level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
331+
let mut res = vec![];
332+
if root.is_none() {
333+
return res;
334+
}
335+
let mut is_desc = false;
336+
let mut q = VecDeque::new();
337+
q.push_back(root);
338+
while !q.is_empty() {
339+
let mut arr = vec![];
340+
for _ in 0..q.len() {
341+
if let Some(node) = q.pop_front().unwrap() {
342+
let mut node = node.borrow_mut();
343+
arr.push(node.val);
344+
if node.left.is_some() {
345+
q.push_back(node.left.take());
346+
}
347+
if node.right.is_some() {
348+
q.push_back(node.right.take());
349+
}
350+
}
351+
}
352+
if is_desc {
353+
arr.reverse();
354+
}
355+
is_desc = !is_desc;
356+
res.push(arr);
357+
}
358+
res
359+
}
360+
}
361+
```
362+
267363
### **...**
268364

269365
```

‎solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README_EN.md

+96
Original file line numberDiff line numberDiff line change
@@ -254,6 +254,102 @@ var zigzagLevelOrder = function (root) {
254254
};
255255
```
256256

257+
### **TypeScript**
258+
259+
```ts
260+
/**
261+
* Definition for a binary tree node.
262+
* class TreeNode {
263+
* val: number
264+
* left: TreeNode | null
265+
* right: TreeNode | null
266+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
267+
* this.val = (val===undefined ? 0 : val)
268+
* this.left = (left===undefined ? null : left)
269+
* this.right = (right===undefined ? null : right)
270+
* }
271+
* }
272+
*/
273+
274+
function zigzagLevelOrder(root: TreeNode | null): number[][] {
275+
const res = [];
276+
if (root == null) {
277+
return res;
278+
}
279+
let isDesc = false;
280+
const queue = [root];
281+
while (queue.length !== 0) {
282+
const arr = queue.slice().map(() => {
283+
const { val, left, right } = queue.shift();
284+
left && queue.push(left);
285+
right && queue.push(right);
286+
return val;
287+
});
288+
res.push(isDesc ? arr.reverse() : arr);
289+
isDesc = !isDesc;
290+
}
291+
return res;
292+
}
293+
```
294+
295+
### **Rust**
296+
297+
```rust
298+
// Definition for a binary tree node.
299+
// #[derive(Debug, PartialEq, Eq)]
300+
// pub struct TreeNode {
301+
// pub val: i32,
302+
// pub left: Option<Rc<RefCell<TreeNode>>>,
303+
// pub right: Option<Rc<RefCell<TreeNode>>>,
304+
// }
305+
//
306+
// impl TreeNode {
307+
// #[inline]
308+
// pub fn new(val: i32) -> Self {
309+
// TreeNode {
310+
// val,
311+
// left: None,
312+
// right: None
313+
// }
314+
// }
315+
// }
316+
use std::rc::Rc;
317+
use std::cell::RefCell;
318+
use std::collections::VecDeque;
319+
impl Solution {
320+
pub fn zigzag_level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
321+
let mut res = vec![];
322+
if root.is_none() {
323+
return res;
324+
}
325+
let mut is_desc = false;
326+
let mut q = VecDeque::new();
327+
q.push_back(root);
328+
while !q.is_empty() {
329+
let mut arr = vec![];
330+
for _ in 0..q.len() {
331+
if let Some(node) = q.pop_front().unwrap() {
332+
let mut node = node.borrow_mut();
333+
arr.push(node.val);
334+
if node.left.is_some() {
335+
q.push_back(node.left.take());
336+
}
337+
if node.right.is_some() {
338+
q.push_back(node.right.take());
339+
}
340+
}
341+
}
342+
if is_desc {
343+
arr.reverse();
344+
}
345+
is_desc = !is_desc;
346+
res.push(arr);
347+
}
348+
res
349+
}
350+
}
351+
```
352+
257353
### **...**
258354

259355
```

‎solution/0100-0199/0103.Binary Tree Zigzag Level Order 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+
use std::collections::VecDeque;
22+
impl Solution {
23+
pub fn zigzag_level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
24+
let mut res = vec![];
25+
if root.is_none() {
26+
return res;
27+
}
28+
let mut is_desc = false;
29+
let mut q = VecDeque::new();
30+
q.push_back(root);
31+
while !q.is_empty() {
32+
let mut arr = vec![];
33+
for _ in 0..q.len() {
34+
if let Some(node) = q.pop_front().unwrap() {
35+
let mut node = node.borrow_mut();
36+
arr.push(node.val);
37+
if node.left.is_some() {
38+
q.push_back(node.left.take());
39+
}
40+
if node.right.is_some() {
41+
q.push_back(node.right.take());
42+
}
43+
}
44+
}
45+
if is_desc {
46+
arr.reverse();
47+
}
48+
is_desc = !is_desc;
49+
res.push(arr);
50+
}
51+
res
52+
}
53+
}

‎solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/Solution.ts

+33
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
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 zigzagLevelOrder(root: TreeNode | null): number[][] {
16+
const res = [];
17+
if (root == null) {
18+
return res;
19+
}
20+
let isDesc = false;
21+
const queue = [root];
22+
while (queue.length !== 0) {
23+
const arr = queue.slice().map(() => {
24+
const { val, left, right } = queue.shift();
25+
left && queue.push(left);
26+
right && queue.push(right);
27+
return val;
28+
});
29+
res.push(isDesc ? arr.reverse() : arr);
30+
isDesc = !isDesc;
31+
}
32+
return res;
33+
}

‎solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README.md

+75
Original file line numberDiff line numberDiff line change
@@ -186,6 +186,81 @@ func buildTree(preorder []int, inorder []int) *TreeNode {
186186
}
187187
```
188188

189+
### **TypeScript**
190+
191+
```ts
192+
/**
193+
* Definition for a binary tree node.
194+
* class TreeNode {
195+
* val: number
196+
* left: TreeNode | null
197+
* right: TreeNode | null
198+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
199+
* this.val = (val===undefined ? 0 : val)
200+
* this.left = (left===undefined ? null : left)
201+
* this.right = (right===undefined ? null : right)
202+
* }
203+
* }
204+
*/
205+
206+
function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
207+
const n = preorder.length;
208+
if (n === 0) {
209+
return null;
210+
}
211+
const val = preorder[0];
212+
const index = inorder.indexOf(val);
213+
return new TreeNode(
214+
val,
215+
buildTree(preorder.slice(1, index + 1), inorder.slice(0, index)),
216+
buildTree(preorder.slice(index + 1), inorder.slice(index + 1)),
217+
);
218+
}
219+
```
220+
221+
### **Rust**
222+
223+
```rust
224+
// Definition for a binary tree node.
225+
// #[derive(Debug, PartialEq, Eq)]
226+
// pub struct TreeNode {
227+
// pub val: i32,
228+
// pub left: Option<Rc<RefCell<TreeNode>>>,
229+
// pub right: Option<Rc<RefCell<TreeNode>>>,
230+
// }
231+
//
232+
// impl TreeNode {
233+
// #[inline]
234+
// pub fn new(val: i32) -> Self {
235+
// TreeNode {
236+
// val,
237+
// left: None,
238+
// right: None
239+
// }
240+
// }
241+
// }
242+
use std::rc::Rc;
243+
use std::cell::RefCell;
244+
impl Solution {
245+
fn to_tree(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
246+
if preorder.is_empty() {
247+
return None;
248+
}
249+
let val = preorder[0];
250+
let index = inorder.iter().position(|&v| v == val).unwrap();
251+
Some(Rc::new(RefCell::new(TreeNode {
252+
val,
253+
left: Self::to_tree(&preorder[1..index + 1], &inorder[..index]),
254+
right: Self::to_tree(&preorder[index + 1..], &inorder[index + 1..]),
255+
})))
256+
}
257+
258+
pub fn build_tree(preorder: Vec<i32>, inorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
259+
Self::to_tree(&preorder[..], &inorder[..])
260+
}
261+
}
262+
```
263+
189264
### **...**
190265

191266
```

0 commit comments

Comments
 (0)