Skip to content

Commit cd8e915

Browse files
YangFongYangFong
committed
feat: add solutions to lc problem: No.0515
No.0515.Find Largest Value in Each Tree Row
1 parent faf59bf commit cd8e915

File tree

4 files changed

+416
-1
lines changed

4 files changed

+416
-1
lines changed

‎solution/0500-0599/0515.Find Largest Value in Each Tree Row/README.md

Lines changed: 169 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -99,7 +99,7 @@ class Solution:
9999
ans[curr] = max(ans[curr], root.val)
100100
dfs(root.left, curr + 1)
101101
dfs(root.right, curr + 1)
102-
102+
103103
ans = []
104104
dfs(root, 0)
105105
return ans
@@ -339,6 +339,174 @@ func max(a, b int) int {
339339
}
340340
```
341341

342+
### **TypeScript**
343+
344+
```ts
345+
/**
346+
* Definition for a binary tree node.
347+
* class TreeNode {
348+
* val: number
349+
* left: TreeNode | null
350+
* right: TreeNode | null
351+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
352+
* this.val = (val===undefined ? 0 : val)
353+
* this.left = (left===undefined ? null : left)
354+
* this.right = (right===undefined ? null : right)
355+
* }
356+
* }
357+
*/
358+
359+
function largestValues(root: TreeNode | null): number[] {
360+
const res: number[] = [];
361+
const queue: TreeNode[] = [];
362+
if (root) {
363+
queue.push(root);
364+
}
365+
while (queue.length) {
366+
const n = queue.length;
367+
let max = -Infinity;
368+
for (let i = 0; i < n; i++) {
369+
const { val, left, right } = queue.shift();
370+
max = Math.max(max, val);
371+
left && queue.push(left);
372+
right && queue.push(right);
373+
}
374+
res.push(max);
375+
}
376+
return res;
377+
}
378+
```
379+
380+
```ts
381+
/**
382+
* Definition for a binary tree node.
383+
* class TreeNode {
384+
* val: number
385+
* left: TreeNode | null
386+
* right: TreeNode | null
387+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
388+
* this.val = (val===undefined ? 0 : val)
389+
* this.left = (left===undefined ? null : left)
390+
* this.right = (right===undefined ? null : right)
391+
* }
392+
* }
393+
*/
394+
395+
function largestValues(root: TreeNode | null): number[] {
396+
const res = [];
397+
const dfs = (root: TreeNode | null, depth: number) => {
398+
if (root == null) {
399+
return;
400+
}
401+
const { val, left, right } = root;
402+
if (res.length == depth) {
403+
res.push(val);
404+
} else {
405+
res[depth] = Math.max(res[depth], val);
406+
}
407+
dfs(left, depth + 1);
408+
dfs(right, depth + 1);
409+
};
410+
dfs(root, 0);
411+
return res;
412+
}
413+
```
414+
415+
### **Rust**
416+
417+
```rust
418+
// Definition for a binary tree node.
419+
// #[derive(Debug, PartialEq, Eq)]
420+
// pub struct TreeNode {
421+
// pub val: i32,
422+
// pub left: Option<Rc<RefCell<TreeNode>>>,
423+
// pub right: Option<Rc<RefCell<TreeNode>>>,
424+
// }
425+
//
426+
// impl TreeNode {
427+
// #[inline]
428+
// pub fn new(val: i32) -> Self {
429+
// TreeNode {
430+
// val,
431+
// left: None,
432+
// right: None
433+
// }
434+
// }
435+
// }
436+
use std::rc::Rc;
437+
use std::cell::RefCell;
438+
use std::collections::VecDeque;
439+
impl Solution {
440+
pub fn largest_values(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<i32> {
441+
let mut res = Vec::new();
442+
let mut queue = VecDeque::new();
443+
if root.is_some() {
444+
queue.push_back(root.clone());
445+
}
446+
while !queue.is_empty() {
447+
let mut max = i32::MIN;
448+
for _ in 0..queue.len() {
449+
let node = queue.pop_front().unwrap();
450+
let node = node.as_ref().unwrap().borrow();
451+
max = max.max(node.val);
452+
if node.left.is_some() {
453+
queue.push_back(node.left.clone());
454+
}
455+
if node.right.is_some() {
456+
queue.push_back(node.right.clone());
457+
}
458+
}
459+
res.push(max);
460+
}
461+
res
462+
}
463+
}
464+
```
465+
466+
```rust
467+
// Definition for a binary tree node.
468+
// #[derive(Debug, PartialEq, Eq)]
469+
// pub struct TreeNode {
470+
// pub val: i32,
471+
// pub left: Option<Rc<RefCell<TreeNode>>>,
472+
// pub right: Option<Rc<RefCell<TreeNode>>>,
473+
// }
474+
//
475+
// impl TreeNode {
476+
// #[inline]
477+
// pub fn new(val: i32) -> Self {
478+
// TreeNode {
479+
// val,
480+
// left: None,
481+
// right: None
482+
// }
483+
// }
484+
// }
485+
use std::rc::Rc;
486+
use std::cell::RefCell;
487+
impl Solution {
488+
fn dfs(root: &Option<Rc<RefCell<TreeNode>>>, depth: usize, res: &mut Vec<i32>) {
489+
if root.is_none() {
490+
return;
491+
}
492+
let node = root.as_ref().unwrap().borrow();
493+
if res.len() == depth {
494+
res.push(node.val);
495+
} else {
496+
res[depth] = res[depth].max(node.val);
497+
}
498+
Self::dfs(&node.left, depth + 1, res);
499+
Self::dfs(&node.right, depth + 1, res);
500+
}
501+
502+
pub fn largest_values(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<i32> {
503+
let mut res = Vec::new();
504+
Self::dfs(&root, 0, &mut res);
505+
res
506+
}
507+
}
508+
```
509+
342510
### **...**
343511

344512
```

‎solution/0500-0599/0515.Find Largest Value in Each Tree Row/README_EN.md

Lines changed: 168 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -317,6 +317,174 @@ func max(a, b int) int {
317317
}
318318
```
319319

320+
### **TypeScript**
321+
322+
```ts
323+
/**
324+
* Definition for a binary tree node.
325+
* class TreeNode {
326+
* val: number
327+
* left: TreeNode | null
328+
* right: TreeNode | null
329+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
330+
* this.val = (val===undefined ? 0 : val)
331+
* this.left = (left===undefined ? null : left)
332+
* this.right = (right===undefined ? null : right)
333+
* }
334+
* }
335+
*/
336+
337+
function largestValues(root: TreeNode | null): number[] {
338+
const res: number[] = [];
339+
const queue: TreeNode[] = [];
340+
if (root) {
341+
queue.push(root);
342+
}
343+
while (queue.length) {
344+
const n = queue.length;
345+
let max = -Infinity;
346+
for (let i = 0; i < n; i++) {
347+
const { val, left, right } = queue.shift();
348+
max = Math.max(max, val);
349+
left && queue.push(left);
350+
right && queue.push(right);
351+
}
352+
res.push(max);
353+
}
354+
return res;
355+
}
356+
```
357+
358+
```ts
359+
/**
360+
* Definition for a binary tree node.
361+
* class TreeNode {
362+
* val: number
363+
* left: TreeNode | null
364+
* right: TreeNode | null
365+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
366+
* this.val = (val===undefined ? 0 : val)
367+
* this.left = (left===undefined ? null : left)
368+
* this.right = (right===undefined ? null : right)
369+
* }
370+
* }
371+
*/
372+
373+
function largestValues(root: TreeNode | null): number[] {
374+
const res = [];
375+
const dfs = (root: TreeNode | null, depth: number) => {
376+
if (root == null) {
377+
return;
378+
}
379+
const { val, left, right } = root;
380+
if (res.length == depth) {
381+
res.push(val);
382+
} else {
383+
res[depth] = Math.max(res[depth], val);
384+
}
385+
dfs(left, depth + 1);
386+
dfs(right, depth + 1);
387+
};
388+
dfs(root, 0);
389+
return res;
390+
}
391+
```
392+
393+
### **Rust**
394+
395+
```rust
396+
// Definition for a binary tree node.
397+
// #[derive(Debug, PartialEq, Eq)]
398+
// pub struct TreeNode {
399+
// pub val: i32,
400+
// pub left: Option<Rc<RefCell<TreeNode>>>,
401+
// pub right: Option<Rc<RefCell<TreeNode>>>,
402+
// }
403+
//
404+
// impl TreeNode {
405+
// #[inline]
406+
// pub fn new(val: i32) -> Self {
407+
// TreeNode {
408+
// val,
409+
// left: None,
410+
// right: None
411+
// }
412+
// }
413+
// }
414+
use std::rc::Rc;
415+
use std::cell::RefCell;
416+
use std::collections::VecDeque;
417+
impl Solution {
418+
pub fn largest_values(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<i32> {
419+
let mut res = Vec::new();
420+
let mut queue = VecDeque::new();
421+
if root.is_some() {
422+
queue.push_back(root.clone());
423+
}
424+
while !queue.is_empty() {
425+
let mut max = i32::MIN;
426+
for _ in 0..queue.len() {
427+
let node = queue.pop_front().unwrap();
428+
let node = node.as_ref().unwrap().borrow();
429+
max = max.max(node.val);
430+
if node.left.is_some() {
431+
queue.push_back(node.left.clone());
432+
}
433+
if node.right.is_some() {
434+
queue.push_back(node.right.clone());
435+
}
436+
}
437+
res.push(max);
438+
}
439+
res
440+
}
441+
}
442+
```
443+
444+
```rust
445+
// Definition for a binary tree node.
446+
// #[derive(Debug, PartialEq, Eq)]
447+
// pub struct TreeNode {
448+
// pub val: i32,
449+
// pub left: Option<Rc<RefCell<TreeNode>>>,
450+
// pub right: Option<Rc<RefCell<TreeNode>>>,
451+
// }
452+
//
453+
// impl TreeNode {
454+
// #[inline]
455+
// pub fn new(val: i32) -> Self {
456+
// TreeNode {
457+
// val,
458+
// left: None,
459+
// right: None
460+
// }
461+
// }
462+
// }
463+
use std::rc::Rc;
464+
use std::cell::RefCell;
465+
impl Solution {
466+
fn dfs(root: &Option<Rc<RefCell<TreeNode>>>, depth: usize, res: &mut Vec<i32>) {
467+
if root.is_none() {
468+
return;
469+
}
470+
let node = root.as_ref().unwrap().borrow();
471+
if res.len() == depth {
472+
res.push(node.val);
473+
} else {
474+
res[depth] = res[depth].max(node.val);
475+
}
476+
Self::dfs(&node.left, depth + 1, res);
477+
Self::dfs(&node.right, depth + 1, res);
478+
}
479+
480+
pub fn largest_values(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<i32> {
481+
let mut res = Vec::new();
482+
Self::dfs(&root, 0, &mut res);
483+
res
484+
}
485+
}
486+
```
487+
320488
### **...**
321489

322490
```

0 commit comments

Comments
 (0)