Skip to content

Commit 30d83d7

Browse files
YangFongYangFong
committed
feat: add solutions to lcci problem: No.04.03
No.04.03.List of Depth
1 parent 52e97e3 commit 30d83d7

File tree

4 files changed

+362
-0
lines changed

4 files changed

+362
-0
lines changed

‎lcci/04.03.List of Depth/README.md

Lines changed: 124 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -218,6 +218,130 @@ func listOfDepth(tree *TreeNode) []*ListNode {
218218
}
219219
```
220220

221+
### **TypeScript**
222+
223+
```ts
224+
/**
225+
* Definition for a binary tree node.
226+
* class TreeNode {
227+
* val: number
228+
* left: TreeNode | null
229+
* right: TreeNode | null
230+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
231+
* this.val = (val===undefined ? 0 : val)
232+
* this.left = (left===undefined ? null : left)
233+
* this.right = (right===undefined ? null : right)
234+
* }
235+
* }
236+
*/
237+
238+
/**
239+
* Definition for singly-linked list.
240+
* class ListNode {
241+
* val: number
242+
* next: ListNode | null
243+
* constructor(val?: number, next?: ListNode | null) {
244+
* this.val = (val===undefined ? 0 : val)
245+
* this.next = (next===undefined ? null : next)
246+
* }
247+
* }
248+
*/
249+
250+
function listOfDepth(tree: TreeNode | null): Array<ListNode | null> {
251+
const res = [];
252+
if (tree == null) {
253+
return res;
254+
}
255+
const queue = [tree];
256+
while (queue.length !== 0) {
257+
const n = queue.length;
258+
const dummy = new ListNode();
259+
let cur = dummy;
260+
for (let i = 0; i < n; i++) {
261+
const { val, left, right } = queue.shift();
262+
left && queue.push(left);
263+
right && queue.push(right);
264+
cur.next = new ListNode(val);
265+
cur = cur.next;
266+
}
267+
res.push(dummy.next);
268+
}
269+
return res;
270+
}
271+
```
272+
273+
### **Rust**
274+
275+
```rust
276+
// Definition for a binary tree node.
277+
// #[derive(Debug, PartialEq, Eq)]
278+
// pub struct TreeNode {
279+
// pub val: i32,
280+
// pub left: Option<Rc<RefCell<TreeNode>>>,
281+
// pub right: Option<Rc<RefCell<TreeNode>>>,
282+
// }
283+
//
284+
// impl TreeNode {
285+
// #[inline]
286+
// pub fn new(val: i32) -> Self {
287+
// TreeNode {
288+
// val,
289+
// left: None,
290+
// right: None
291+
// }
292+
// }
293+
// }
294+
// Definition for singly-linked list.
295+
// #[derive(PartialEq, Eq, Clone, Debug)]
296+
// pub struct ListNode {
297+
// pub val: i32,
298+
// pub next: Option<Box<ListNode>>
299+
// }
300+
//
301+
// impl ListNode {
302+
// #[inline]
303+
// fn new(val: i32) -> Self {
304+
// ListNode {
305+
// next: None,
306+
// val
307+
// }
308+
// }
309+
// }
310+
use std::rc::Rc;
311+
use std::cell::RefCell;
312+
use std::collections::VecDeque;
313+
impl Solution {
314+
pub fn list_of_depth(tree: Option<Rc<RefCell<TreeNode>>>) -> Vec<Option<Box<ListNode>>> {
315+
let mut res = vec![];
316+
if tree.is_none() {
317+
return res;
318+
}
319+
let mut q = VecDeque::new();
320+
q.push_back(tree);
321+
while !q.is_empty() {
322+
let n = q.len();
323+
let mut demmy = Some(Box::new(ListNode::new(0)));
324+
let mut cur = &mut demmy;
325+
for _ in 0..n {
326+
if let Some(node) = q.pop_front().unwrap() {
327+
let mut node = node.borrow_mut();
328+
if node.left.is_some() {
329+
q.push_back(node.left.take());
330+
}
331+
if node.right.is_some() {
332+
q.push_back(node.right.take());
333+
}
334+
cur.as_mut().unwrap().next = Some(Box::new(ListNode::new(node.val)));
335+
cur = &mut cur.as_mut().unwrap().next;
336+
}
337+
}
338+
res.push(demmy.as_mut().unwrap().next.take());
339+
}
340+
res
341+
}
342+
}
343+
```
344+
221345
### **...**
222346

223347
```

‎lcci/04.03.List of Depth/README_EN.md

Lines changed: 124 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -224,6 +224,130 @@ func listOfDepth(tree *TreeNode) []*ListNode {
224224
}
225225
```
226226

227+
### **TypeScript**
228+
229+
```ts
230+
/**
231+
* Definition for a binary tree node.
232+
* class TreeNode {
233+
* val: number
234+
* left: TreeNode | null
235+
* right: TreeNode | null
236+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
237+
* this.val = (val===undefined ? 0 : val)
238+
* this.left = (left===undefined ? null : left)
239+
* this.right = (right===undefined ? null : right)
240+
* }
241+
* }
242+
*/
243+
244+
/**
245+
* Definition for singly-linked list.
246+
* class ListNode {
247+
* val: number
248+
* next: ListNode | null
249+
* constructor(val?: number, next?: ListNode | null) {
250+
* this.val = (val===undefined ? 0 : val)
251+
* this.next = (next===undefined ? null : next)
252+
* }
253+
* }
254+
*/
255+
256+
function listOfDepth(tree: TreeNode | null): Array<ListNode | null> {
257+
const res = [];
258+
if (tree == null) {
259+
return res;
260+
}
261+
const queue = [tree];
262+
while (queue.length !== 0) {
263+
const n = queue.length;
264+
const dummy = new ListNode();
265+
let cur = dummy;
266+
for (let i = 0; i < n; i++) {
267+
const { val, left, right } = queue.shift();
268+
left && queue.push(left);
269+
right && queue.push(right);
270+
cur.next = new ListNode(val);
271+
cur = cur.next;
272+
}
273+
res.push(dummy.next);
274+
}
275+
return res;
276+
}
277+
```
278+
279+
### **Rust**
280+
281+
```rust
282+
// Definition for a binary tree node.
283+
// #[derive(Debug, PartialEq, Eq)]
284+
// pub struct TreeNode {
285+
// pub val: i32,
286+
// pub left: Option<Rc<RefCell<TreeNode>>>,
287+
// pub right: Option<Rc<RefCell<TreeNode>>>,
288+
// }
289+
//
290+
// impl TreeNode {
291+
// #[inline]
292+
// pub fn new(val: i32) -> Self {
293+
// TreeNode {
294+
// val,
295+
// left: None,
296+
// right: None
297+
// }
298+
// }
299+
// }
300+
// Definition for singly-linked list.
301+
// #[derive(PartialEq, Eq, Clone, Debug)]
302+
// pub struct ListNode {
303+
// pub val: i32,
304+
// pub next: Option<Box<ListNode>>
305+
// }
306+
//
307+
// impl ListNode {
308+
// #[inline]
309+
// fn new(val: i32) -> Self {
310+
// ListNode {
311+
// next: None,
312+
// val
313+
// }
314+
// }
315+
// }
316+
use std::rc::Rc;
317+
use std::cell::RefCell;
318+
use std::collections::VecDeque;
319+
impl Solution {
320+
pub fn list_of_depth(tree: Option<Rc<RefCell<TreeNode>>>) -> Vec<Option<Box<ListNode>>> {
321+
let mut res = vec![];
322+
if tree.is_none() {
323+
return res;
324+
}
325+
let mut q = VecDeque::new();
326+
q.push_back(tree);
327+
while !q.is_empty() {
328+
let n = q.len();
329+
let mut demmy = Some(Box::new(ListNode::new(0)));
330+
let mut cur = &mut demmy;
331+
for _ in 0..n {
332+
if let Some(node) = q.pop_front().unwrap() {
333+
let mut node = node.borrow_mut();
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+
cur.as_mut().unwrap().next = Some(Box::new(ListNode::new(node.val)));
341+
cur = &mut cur.as_mut().unwrap().next;
342+
}
343+
}
344+
res.push(demmy.as_mut().unwrap().next.take());
345+
}
346+
res
347+
}
348+
}
349+
```
350+
227351
### **...**
228352

229353
```

‎lcci/04.03.List of Depth/Solution.rs

Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,67 @@
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+
// Definition for singly-linked list.
20+
// #[derive(PartialEq, Eq, Clone, Debug)]
21+
// pub struct ListNode {
22+
// pub val: i32,
23+
// pub next: Option<Box<ListNode>>
24+
// }
25+
//
26+
// impl ListNode {
27+
// #[inline]
28+
// fn new(val: i32) -> Self {
29+
// ListNode {
30+
// next: None,
31+
// val
32+
// }
33+
// }
34+
// }
35+
use std::rc::Rc;
36+
use std::cell::RefCell;
37+
use std::collections::VecDeque;
38+
impl Solution {
39+
pub fn list_of_depth(tree: Option<Rc<RefCell<TreeNode>>>) -> Vec<Option<Box<ListNode>>> {
40+
let mut res = vec![];
41+
if tree.is_none() {
42+
return res;
43+
}
44+
let mut q = VecDeque::new();
45+
q.push_back(tree);
46+
while !q.is_empty() {
47+
let n = q.len();
48+
let mut demmy = Some(Box::new(ListNode::new(0)));
49+
let mut cur = &mut demmy;
50+
for _ in 0..n {
51+
if let Some(node) = q.pop_front().unwrap() {
52+
let mut node = node.borrow_mut();
53+
if node.left.is_some() {
54+
q.push_back(node.left.take());
55+
}
56+
if node.right.is_some() {
57+
q.push_back(node.right.take());
58+
}
59+
cur.as_mut().unwrap().next = Some(Box::new(ListNode::new(node.val)));
60+
cur = &mut cur.as_mut().unwrap().next;
61+
}
62+
}
63+
res.push(demmy.as_mut().unwrap().next.take());
64+
}
65+
res
66+
}
67+
}

‎lcci/04.03.List of Depth/Solution.ts

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
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+
/**
16+
* Definition for singly-linked list.
17+
* class ListNode {
18+
* val: number
19+
* next: ListNode | null
20+
* constructor(val?: number, next?: ListNode | null) {
21+
* this.val = (val===undefined ? 0 : val)
22+
* this.next = (next===undefined ? null : next)
23+
* }
24+
* }
25+
*/
26+
27+
function listOfDepth(tree: TreeNode | null): Array<ListNode | null> {
28+
const res = [];
29+
if (tree == null) {
30+
return res;
31+
}
32+
const queue = [tree];
33+
while (queue.length !== 0) {
34+
const n = queue.length;
35+
const dummy = new ListNode();
36+
let cur = dummy;
37+
for (let i = 0; i < n; i++) {
38+
const { val, left, right } = queue.shift();
39+
left && queue.push(left);
40+
right && queue.push(right);
41+
cur.next = new ListNode(val);
42+
cur = cur.next;
43+
}
44+
res.push(dummy.next);
45+
}
46+
return res;
47+
}

0 commit comments

Comments
 (0)