Skip to content

Commit 9010e98

Browse files
YangFongYangFong
committed
feat: add solutions to lc problems: No.0102,0145
- No.0102.Binary Tree Level Order Traversal - No.0145.Binary Tree Postorder Traversal
1 parent 03d4423 commit 9010e98

File tree

7 files changed

+612
-0
lines changed

7 files changed

+612
-0
lines changed

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

+93
Original file line numberDiff line numberDiff line change
@@ -240,6 +240,99 @@ var levelOrder = function (root) {
240240
};
241241
```
242242

243+
### **TypeScript**
244+
245+
```ts
246+
/**
247+
* Definition for a binary tree node.
248+
* class TreeNode {
249+
* val: number
250+
* left: TreeNode | null
251+
* right: TreeNode | null
252+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
253+
* this.val = (val===undefined ? 0 : val)
254+
* this.left = (left===undefined ? null : left)
255+
* this.right = (right===undefined ? null : right)
256+
* }
257+
* }
258+
*/
259+
260+
function levelOrder(root: TreeNode | null): number[][] {
261+
const res = [];
262+
if (root == null) {
263+
return res;
264+
}
265+
const queue = [root];
266+
while (queue.length != 0) {
267+
const n = queue.length;
268+
res.push(
269+
new Array(n).fill(null).map(() => {
270+
const { val, left, right } = queue.shift();
271+
left && queue.push(left);
272+
right && queue.push(right);
273+
return val;
274+
}),
275+
);
276+
}
277+
return res;
278+
}
279+
```
280+
281+
### **Rust**
282+
283+
```rust
284+
// Definition for a binary tree node.
285+
// #[derive(Debug, PartialEq, Eq)]
286+
// pub struct TreeNode {
287+
// pub val: i32,
288+
// pub left: Option<Rc<RefCell<TreeNode>>>,
289+
// pub right: Option<Rc<RefCell<TreeNode>>>,
290+
// }
291+
//
292+
// impl TreeNode {
293+
// #[inline]
294+
// pub fn new(val: i32) -> Self {
295+
// TreeNode {
296+
// val,
297+
// left: None,
298+
// right: None
299+
// }
300+
// }
301+
// }
302+
use std::rc::Rc;
303+
use std::cell::RefCell;
304+
use std::collections::VecDeque;
305+
impl Solution {
306+
pub fn level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
307+
let mut res = vec![];
308+
if root.is_none() {
309+
return res;
310+
}
311+
let mut queue: VecDeque<Option<Rc<RefCell<TreeNode>>>> = vec![root].into_iter().collect();
312+
while !queue.is_empty() {
313+
let n = queue.len();
314+
res.push(
315+
(0..n)
316+
.into_iter()
317+
.map(|_| {
318+
let mut node = queue.pop_front().unwrap();
319+
let mut node = node.as_mut().unwrap().borrow_mut();
320+
if node.left.is_some() {
321+
queue.push_back(node.left.take());
322+
}
323+
if node.right.is_some() {
324+
queue.push_back(node.right.take());
325+
}
326+
node.val
327+
})
328+
.collect(),
329+
);
330+
}
331+
res
332+
}
333+
}
334+
```
335+
243336
### **...**
244337

245338
```

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

+93
Original file line numberDiff line numberDiff line change
@@ -228,6 +228,99 @@ var levelOrder = function (root) {
228228
};
229229
```
230230

231+
### **TypeScript**
232+
233+
```ts
234+
/**
235+
* Definition for a binary tree node.
236+
* class TreeNode {
237+
* val: number
238+
* left: TreeNode | null
239+
* right: TreeNode | null
240+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
241+
* this.val = (val===undefined ? 0 : val)
242+
* this.left = (left===undefined ? null : left)
243+
* this.right = (right===undefined ? null : right)
244+
* }
245+
* }
246+
*/
247+
248+
function levelOrder(root: TreeNode | null): number[][] {
249+
const res = [];
250+
if (root == null) {
251+
return res;
252+
}
253+
const queue = [root];
254+
while (queue.length != 0) {
255+
const n = queue.length;
256+
res.push(
257+
new Array(n).fill(null).map(() => {
258+
const { val, left, right } = queue.shift();
259+
left && queue.push(left);
260+
right && queue.push(right);
261+
return val;
262+
}),
263+
);
264+
}
265+
return res;
266+
}
267+
```
268+
269+
### **Rust**
270+
271+
```rust
272+
// Definition for a binary tree node.
273+
// #[derive(Debug, PartialEq, Eq)]
274+
// pub struct TreeNode {
275+
// pub val: i32,
276+
// pub left: Option<Rc<RefCell<TreeNode>>>,
277+
// pub right: Option<Rc<RefCell<TreeNode>>>,
278+
// }
279+
//
280+
// impl TreeNode {
281+
// #[inline]
282+
// pub fn new(val: i32) -> Self {
283+
// TreeNode {
284+
// val,
285+
// left: None,
286+
// right: None
287+
// }
288+
// }
289+
// }
290+
use std::rc::Rc;
291+
use std::cell::RefCell;
292+
use std::collections::VecDeque;
293+
impl Solution {
294+
pub fn level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
295+
let mut res = vec![];
296+
if root.is_none() {
297+
return res;
298+
}
299+
let mut queue: VecDeque<Option<Rc<RefCell<TreeNode>>>> = vec![root].into_iter().collect();
300+
while !queue.is_empty() {
301+
let n = queue.len();
302+
res.push(
303+
(0..n)
304+
.into_iter()
305+
.map(|_| {
306+
let mut node = queue.pop_front().unwrap();
307+
let mut node = node.as_mut().unwrap().borrow_mut();
308+
if node.left.is_some() {
309+
queue.push_back(node.left.take());
310+
}
311+
if node.right.is_some() {
312+
queue.push_back(node.right.take());
313+
}
314+
node.val
315+
})
316+
.collect(),
317+
);
318+
}
319+
res
320+
}
321+
}
322+
```
323+
231324
### **...**
232325

233326
```

‎solution/0100-0199/0102.Binary Tree Level Order Traversal/Solution.rs

+50
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,50 @@
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 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 queue: VecDeque<Option<Rc<RefCell<TreeNode>>>> = vec![root].into_iter().collect();
29+
while !queue.is_empty() {
30+
let n = queue.len();
31+
res.push(
32+
(0..n)
33+
.into_iter()
34+
.map(|_| {
35+
let mut node = queue.pop_front().unwrap();
36+
let mut node = node.as_mut().unwrap().borrow_mut();
37+
if node.left.is_some() {
38+
queue.push_back(node.left.take());
39+
}
40+
if node.right.is_some() {
41+
queue.push_back(node.right.take());
42+
}
43+
node.val
44+
})
45+
.collect(),
46+
);
47+
}
48+
res
49+
}
50+
}

‎solution/0100-0199/0102.Binary Tree 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 levelOrder(root: TreeNode | null): number[][] {
16+
const res = [];
17+
if (root == null) {
18+
return res;
19+
}
20+
const queue = [root];
21+
while (queue.length != 0) {
22+
const n = queue.length;
23+
res.push(
24+
new Array(n).fill(null).map(() => {
25+
const { val, left, right } = queue.shift();
26+
left && queue.push(left);
27+
right && queue.push(right);
28+
return val;
29+
}),
30+
);
31+
}
32+
return res;
33+
}

0 commit comments

Comments
 (0)