Skip to content

Commit d080185

Browse files
YangFongYangFong
committed
feat: add solutions to lc problem: No.0129
No.0129.Sum Root to Leaf Numbers
1 parent cc341f3 commit d080185

File tree

4 files changed

+258
-58
lines changed

4 files changed

+258
-58
lines changed

‎solution/0100-0199/0129.Sum Root to Leaf Numbers/README.md

Lines changed: 99 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -126,35 +126,6 @@ class Solution {
126126
}
127127
```
128128

129-
### **TypeScript**
130-
131-
```ts
132-
/**
133-
* Definition for a binary tree node.
134-
* class TreeNode {
135-
* val: number
136-
* left: TreeNode | null
137-
* right: TreeNode | null
138-
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
139-
* this.val = (val===undefined ? 0 : val)
140-
* this.left = (left===undefined ? null : left)
141-
* this.right = (right===undefined ? null : right)
142-
* }
143-
* }
144-
*/
145-
146-
function sumNumbers(root: TreeNode | null): number {
147-
return dfs(root);
148-
}
149-
150-
function dfs(root: TreeNode | null, preSum: number = 0): number {
151-
if (!root) return 0;
152-
preSum = preSum * 10 + root.val;
153-
if (!root.left && !root.right) return preSum;
154-
return dfs(root.left, preSum) + dfs(root.right, preSum);
155-
}
156-
```
157-
158129
### **C++**
159130

160131
```cpp
@@ -211,6 +182,105 @@ func sumNumbers(root *TreeNode) int {
211182
}
212183
```
213184

185+
### **C**
186+
187+
```c
188+
/**
189+
* Definition for a binary tree node.
190+
* struct TreeNode {
191+
* int val;
192+
* struct TreeNode *left;
193+
* struct TreeNode *right;
194+
* };
195+
*/
196+
197+
int dfs(struct TreeNode *root, int num) {
198+
if (!root) {
199+
return 0;
200+
}
201+
num = num * 10 + root->val;
202+
if (!root->left && !root->right) {
203+
return num;
204+
}
205+
return dfs(root->left, num) + dfs(root->right, num);
206+
}
207+
208+
int sumNumbers(struct TreeNode *root) {
209+
return dfs(root, 0);
210+
}
211+
```
212+
213+
### **TypeScript**
214+
215+
```ts
216+
/**
217+
* Definition for a binary tree node.
218+
* class TreeNode {
219+
* val: number
220+
* left: TreeNode | null
221+
* right: TreeNode | null
222+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
223+
* this.val = (val===undefined ? 0 : val)
224+
* this.left = (left===undefined ? null : left)
225+
* this.right = (right===undefined ? null : right)
226+
* }
227+
* }
228+
*/
229+
230+
function sumNumbers(root: TreeNode | null): number {
231+
return dfs(root);
232+
}
233+
234+
function dfs(root: TreeNode | null, preSum: number = 0): number {
235+
if (!root) return 0;
236+
preSum = preSum * 10 + root.val;
237+
if (!root.left && !root.right) return preSum;
238+
return dfs(root.left, preSum) + dfs(root.right, preSum);
239+
}
240+
```
241+
242+
### **Rust**
243+
244+
```rust
245+
// Definition for a binary tree node.
246+
// #[derive(Debug, PartialEq, Eq)]
247+
// pub struct TreeNode {
248+
// pub val: i32,
249+
// pub left: Option<Rc<RefCell<TreeNode>>>,
250+
// pub right: Option<Rc<RefCell<TreeNode>>>,
251+
// }
252+
//
253+
// impl TreeNode {
254+
// #[inline]
255+
// pub fn new(val: i32) -> Self {
256+
// TreeNode {
257+
// val,
258+
// left: None,
259+
// right: None
260+
// }
261+
// }
262+
// }
263+
use std::rc::Rc;
264+
use std::cell::RefCell;
265+
impl Solution {
266+
fn dfs(node: &Option<Rc<RefCell<TreeNode>>>, mut num: i32) -> i32 {
267+
if node.is_none() {
268+
return 0;
269+
}
270+
let node = node.as_ref().unwrap().borrow();
271+
num = num * 10 + node.val;
272+
if node.left.is_none() && node.right.is_none() {
273+
return num;
274+
}
275+
Self::dfs(&node.left, num) + Self::dfs(&node.right, num)
276+
}
277+
278+
pub fn sum_numbers(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
279+
Self::dfs(&root, 0)
280+
}
281+
}
282+
```
283+
214284
### **...**
215285

216286
```

‎solution/0100-0199/0129.Sum Root to Leaf Numbers/README_EN.md

Lines changed: 99 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -113,35 +113,6 @@ class Solution {
113113
}
114114
```
115115

116-
### **TypeScript**
117-
118-
```ts
119-
/**
120-
* Definition for a binary tree node.
121-
* class TreeNode {
122-
* val: number
123-
* left: TreeNode | null
124-
* right: TreeNode | null
125-
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
126-
* this.val = (val===undefined ? 0 : val)
127-
* this.left = (left===undefined ? null : left)
128-
* this.right = (right===undefined ? null : right)
129-
* }
130-
* }
131-
*/
132-
133-
function sumNumbers(root: TreeNode | null): number {
134-
return dfs(root);
135-
}
136-
137-
function dfs(root: TreeNode | null, preSum: number = 0): number {
138-
if (!root) return 0;
139-
preSum = preSum * 10 + root.val;
140-
if (!root.left && !root.right) return preSum;
141-
return dfs(root.left, preSum) + dfs(root.right, preSum);
142-
}
143-
```
144-
145116
### **C++**
146117

147118
```cpp
@@ -198,6 +169,105 @@ func sumNumbers(root *TreeNode) int {
198169
}
199170
```
200171

172+
### **C**
173+
174+
```c
175+
/**
176+
* Definition for a binary tree node.
177+
* struct TreeNode {
178+
* int val;
179+
* struct TreeNode *left;
180+
* struct TreeNode *right;
181+
* };
182+
*/
183+
184+
int dfs(struct TreeNode *root, int num) {
185+
if (!root) {
186+
return 0;
187+
}
188+
num = num * 10 + root->val;
189+
if (!root->left && !root->right) {
190+
return num;
191+
}
192+
return dfs(root->left, num) + dfs(root->right, num);
193+
}
194+
195+
int sumNumbers(struct TreeNode *root) {
196+
return dfs(root, 0);
197+
}
198+
```
199+
200+
### **TypeScript**
201+
202+
```ts
203+
/**
204+
* Definition for a binary tree node.
205+
* class TreeNode {
206+
* val: number
207+
* left: TreeNode | null
208+
* right: TreeNode | null
209+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
210+
* this.val = (val===undefined ? 0 : val)
211+
* this.left = (left===undefined ? null : left)
212+
* this.right = (right===undefined ? null : right)
213+
* }
214+
* }
215+
*/
216+
217+
function sumNumbers(root: TreeNode | null): number {
218+
return dfs(root);
219+
}
220+
221+
function dfs(root: TreeNode | null, preSum: number = 0): number {
222+
if (!root) return 0;
223+
preSum = preSum * 10 + root.val;
224+
if (!root.left && !root.right) return preSum;
225+
return dfs(root.left, preSum) + dfs(root.right, preSum);
226+
}
227+
```
228+
229+
### **Rust**
230+
231+
```rust
232+
// Definition for a binary tree node.
233+
// #[derive(Debug, PartialEq, Eq)]
234+
// pub struct TreeNode {
235+
// pub val: i32,
236+
// pub left: Option<Rc<RefCell<TreeNode>>>,
237+
// pub right: Option<Rc<RefCell<TreeNode>>>,
238+
// }
239+
//
240+
// impl TreeNode {
241+
// #[inline]
242+
// pub fn new(val: i32) -> Self {
243+
// TreeNode {
244+
// val,
245+
// left: None,
246+
// right: None
247+
// }
248+
// }
249+
// }
250+
use std::rc::Rc;
251+
use std::cell::RefCell;
252+
impl Solution {
253+
fn dfs(node: &Option<Rc<RefCell<TreeNode>>>, mut num: i32) -> i32 {
254+
if node.is_none() {
255+
return 0;
256+
}
257+
let node = node.as_ref().unwrap().borrow();
258+
num = num * 10 + node.val;
259+
if node.left.is_none() && node.right.is_none() {
260+
return num;
261+
}
262+
Self::dfs(&node.left, num) + Self::dfs(&node.right, num)
263+
}
264+
265+
pub fn sum_numbers(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
266+
Self::dfs(&root, 0)
267+
}
268+
}
269+
```
270+
201271
### **...**
202272

203273
```

‎solution/0100-0199/0129.Sum Root to Leaf Numbers/Solution.c

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* struct TreeNode *left;
6+
* struct TreeNode *right;
7+
* };
8+
*/
9+
10+
int dfs(struct TreeNode *root, int num) {
11+
if (!root) {
12+
return 0;
13+
}
14+
num = num * 10 + root->val;
15+
if (!root->left && !root->right) {
16+
return num;
17+
}
18+
return dfs(root->left, num) + dfs(root->right, num);
19+
}
20+
21+
int sumNumbers(struct TreeNode *root) {
22+
return dfs(root, 0);
23+
}

‎solution/0100-0199/0129.Sum Root to Leaf Numbers/Solution.rs

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
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(node: &Option<Rc<RefCell<TreeNode>>>, mut num: i32) -> i32 {
23+
if node.is_none() {
24+
return 0;
25+
}
26+
let node = node.as_ref().unwrap().borrow();
27+
num = num * 10 + node.val;
28+
if node.left.is_none() && node.right.is_none() {
29+
return num;
30+
}
31+
Self::dfs(&node.left, num) + Self::dfs(&node.right, num)
32+
}
33+
34+
pub fn sum_numbers(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
35+
Self::dfs(&root, 0)
36+
}
37+
}

0 commit comments

Comments
 (0)