Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit d080185

Browse files
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
```
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+
}
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)

AltStyle によって変換されたページ (->オリジナル) /