Skip to content

Commit 97473dd

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0129
No.0129.Sum Root to Leaf Numbers
1 parent 6533dd3 commit 97473dd

File tree

8 files changed

+169
-91
lines changed

8 files changed

+169
-91
lines changed

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

+68-33
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,18 @@
6060

6161
<!-- 这里可写通用的实现逻辑 -->
6262

63-
DFS。
63+
**方法一：DFS**
64+
65+
我们可以设计一个函数 $dfs(root, s)$，表示从当前节点 $root$ 出发，且当前路径数字为 $s$，返回从当前节点到叶子节点的所有路径数字之和。那么答案就是 $dfs(root, 0)$。
66+
67+
函数 $dfs(root, s)$ 的计算如下：
68+
69+
- 如果当前节点 $root$ 为空，则返回 $0$。
70+
- 否则，将当前节点的值加到 $s$ 中，即 $s = s \times 10 + root.val$。
71+
- 如果当前节点是叶子节点，则返回 $s$。
72+
- 否则，返回 $dfs(root.left, s) + dfs(root.right, s)$。
73+
74+
时间复杂度 $O(n)$，空间复杂度 $O(\log n)$。其中 $n$ 是二叉树的节点数。
6475

6576
<!-- tabs:start -->
6677

@@ -76,11 +87,11 @@ DFS。
7687
# self.left = left
7788
# self.right = right
7889
class Solution:
79-
def sumNumbers(self, root: TreeNode) -> int:
80-
def dfs(root, presum):
90+
def sumNumbers(self, root: Optional[TreeNode]) -> int:
91+
def dfs(root, s):
8192
if root is None:
8293
return 0
83-
s = 10 * presum + root.val
94+
s = s * 10 + root.val
8495
if root.left is None and root.right is None:
8596
return s
8697
return dfs(root.left, s) + dfs(root.right, s)
@@ -113,11 +124,11 @@ class Solution {
113124
return dfs(root, 0);
114125
}
115126

116-
private int dfs(TreeNode root, int presum) {
127+
private int dfs(TreeNode root, int s) {
117128
if (root == null) {
118129
return 0;
119130
}
120-
int s = presum * 10 + root.val;
131+
s = s * 10 + root.val;
121132
if (root.left == null && root.right == null) {
122133
return s;
123134
}
@@ -143,15 +154,14 @@ class Solution {
143154
class Solution {
144155
public:
145156
int sumNumbers(TreeNode* root) {
157+
function<int(TreeNode*, int)> dfs = [&](TreeNode* root, int s) -> int {
158+
if (!root) return 0;
159+
s = s * 10 + root->val;
160+
if (!root->left && !root->right) return s;
161+
return dfs(root->left, s) + dfs(root->right, s);
162+
};
146163
return dfs(root, 0);
147164
}
148-
149-
int dfs(TreeNode* root, int presum) {
150-
if (!root) return 0;
151-
int s = presum * 10 + root->val;
152-
if (!root->left && !root->right) return s;
153-
return dfs(root->left, s) + dfs(root->right, s);
154-
}
155165
};
156166
```
157167
@@ -167,18 +177,18 @@ public:
167177
* }
168178
*/
169179
func sumNumbers(root *TreeNode) int {
170-
var dfs func(root *TreeNode, presum int) int
171-
dfs = func(root *TreeNode, presum int) int {
172-
if root == nil {
173-
return 0
174-
}
175-
presum = presum * 10 + root.Val
176-
if root.Left == nil && root.Right == nil {
177-
return presum
178-
}
179-
return dfs(root.Left, presum) + dfs(root.Right, presum)
180-
}
181-
return dfs(root, 0)
180+
var dfs func(*TreeNode, int) int
181+
dfs = func(root *TreeNode, s int) int {
182+
if root == nil {
183+
return 0
184+
}
185+
s = s*10 + root.Val
186+
if root.Left == nil && root.Right == nil {
187+
return s
188+
}
189+
return dfs(root.Left, s) + dfs(root.Right, s)
190+
}
191+
return dfs(root, 0)
182192
}
183193
```
184194

@@ -228,14 +238,13 @@ int sumNumbers(struct TreeNode *root) {
228238
*/
229239
230240
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);
241+
function dfs(root: TreeNode | null, s: number): number {
242+
if (!root) return 0;
243+
s = s * 10 + root.val;
244+
if (!root.left && !root.right) return s;
245+
return dfs(root.left, s) + dfs(root.right, s);
246+
}
247+
return dfs(root, 0);
239248
}
240249
```
241250

@@ -281,6 +290,32 @@ impl Solution {
281290
}
282291
```
283292

293+
### **JavaScript**
294+
295+
```js
296+
/**
297+
* Definition for a binary tree node.
298+
* function TreeNode(val, left, right) {
299+
* this.val = (val===undefined ? 0 : val)
300+
* this.left = (left===undefined ? null : left)
301+
* this.right = (right===undefined ? null : right)
302+
* }
303+
*/
304+
/**
305+
* @param {TreeNode} root
306+
* @return {number}
307+
*/
308+
var sumNumbers = function (root) {
309+
function dfs(root, s) {
310+
if (!root) return 0;
311+
s = s * 10 + root.val;
312+
if (!root.left && !root.right) return s;
313+
return dfs(root.left, s) + dfs(root.right, s);
314+
}
315+
return dfs(root, 0);
316+
};
317+
```
318+
284319
### **...**
285320

286321
```

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

+57-33
Original file line numberDiff line numberDiff line change
@@ -65,15 +65,15 @@ DFS.
6565
# self.left = left
6666
# self.right = right
6767
class Solution:
68-
def sumNumbers(self, root: TreeNode) -> int:
69-
def dfs(root, presum):
68+
def sumNumbers(self, root: Optional[TreeNode]) -> int:
69+
def dfs(root, s):
7070
if root is None:
7171
return 0
72-
s = 10 * presum + root.val
72+
s = s * 10 + root.val
7373
if root.left is None and root.right is None:
7474
return s
7575
return dfs(root.left, s) + dfs(root.right, s)
76-
76+
7777
return dfs(root, 0)
7878
```
7979

@@ -100,11 +100,11 @@ class Solution {
100100
return dfs(root, 0);
101101
}
102102

103-
private int dfs(TreeNode root, int presum) {
103+
private int dfs(TreeNode root, int s) {
104104
if (root == null) {
105105
return 0;
106106
}
107-
int s = presum * 10 + root.val;
107+
s = s * 10 + root.val;
108108
if (root.left == null && root.right == null) {
109109
return s;
110110
}
@@ -130,15 +130,14 @@ class Solution {
130130
class Solution {
131131
public:
132132
int sumNumbers(TreeNode* root) {
133+
function<int(TreeNode*, int)> dfs = [&](TreeNode* root, int s) -> int {
134+
if (!root) return 0;
135+
s = s * 10 + root->val;
136+
if (!root->left && !root->right) return s;
137+
return dfs(root->left, s) + dfs(root->right, s);
138+
};
133139
return dfs(root, 0);
134140
}
135-
136-
int dfs(TreeNode* root, int presum) {
137-
if (!root) return 0;
138-
int s = presum * 10 + root->val;
139-
if (!root->left && !root->right) return s;
140-
return dfs(root->left, s) + dfs(root->right, s);
141-
}
142141
};
143142
```
144143
@@ -154,18 +153,18 @@ public:
154153
* }
155154
*/
156155
func sumNumbers(root *TreeNode) int {
157-
var dfs func(root *TreeNode, presum int) int
158-
dfs = func(root *TreeNode, presum int) int {
159-
if root == nil {
160-
return 0
161-
}
162-
presum = presum * 10 + root.Val
163-
if root.Left == nil && root.Right == nil {
164-
return presum
165-
}
166-
return dfs(root.Left, presum) + dfs(root.Right, presum)
167-
}
168-
return dfs(root, 0)
156+
var dfs func(*TreeNode, int) int
157+
dfs = func(root *TreeNode, s int) int {
158+
if root == nil {
159+
return 0
160+
}
161+
s = s*10 + root.Val
162+
if root.Left == nil && root.Right == nil {
163+
return s
164+
}
165+
return dfs(root.Left, s) + dfs(root.Right, s)
166+
}
167+
return dfs(root, 0)
169168
}
170169
```
171170

@@ -215,14 +214,13 @@ int sumNumbers(struct TreeNode *root) {
215214
*/
216215
217216
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);
217+
function dfs(root: TreeNode | null, s: number): number {
218+
if (!root) return 0;
219+
s = s * 10 + root.val;
220+
if (!root.left && !root.right) return s;
221+
return dfs(root.left, s) + dfs(root.right, s);
222+
}
223+
return dfs(root, 0);
226224
}
227225
```
228226

@@ -268,6 +266,32 @@ impl Solution {
268266
}
269267
```
270268

269+
### **JavaScript**
270+
271+
```js
272+
/**
273+
* Definition for a binary tree node.
274+
* function TreeNode(val, left, right) {
275+
* this.val = (val===undefined ? 0 : val)
276+
* this.left = (left===undefined ? null : left)
277+
* this.right = (right===undefined ? null : right)
278+
* }
279+
*/
280+
/**
281+
* @param {TreeNode} root
282+
* @return {number}
283+
*/
284+
var sumNumbers = function (root) {
285+
function dfs(root, s) {
286+
if (!root) return 0;
287+
s = s * 10 + root.val;
288+
if (!root.left && !root.right) return s;
289+
return dfs(root.left, s) + dfs(root.right, s);
290+
}
291+
return dfs(root, 0);
292+
};
293+
```
294+
271295
### **...**
272296

273297
```

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

+6-7
Original file line numberDiff line numberDiff line change
@@ -12,13 +12,12 @@
1212
class Solution {
1313
public:
1414
int sumNumbers(TreeNode* root) {
15+
function<int(TreeNode*, int)> dfs = [&](TreeNode* root, int s) -> int {
16+
if (!root) return 0;
17+
s = s * 10 + root->val;
18+
if (!root->left && !root->right) return s;
19+
return dfs(root->left, s) + dfs(root->right, s);
20+
};
1521
return dfs(root, 0);
1622
}
17-
18-
int dfs(TreeNode* root, int presum) {
19-
if (!root) return 0;
20-
int s = presum * 10 + root->val;
21-
if (!root->left && !root->right) return s;
22-
return dfs(root->left, s) + dfs(root->right, s);
23-
}
2423
};

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

+5-5
Original file line numberDiff line numberDiff line change
@@ -7,16 +7,16 @@
77
* }
88
*/
99
func sumNumbers(root *TreeNode) int {
10-
var dfs func(root *TreeNode, presum int) int
11-
dfs = func(root *TreeNode, presum int) int {
10+
var dfs func(*TreeNode, int) int
11+
dfs = func(root *TreeNode, s int) int {
1212
if root == nil {
1313
return 0
1414
}
15-
presum = presum*10 + root.Val
15+
s = s*10 + root.Val
1616
if root.Left == nil && root.Right == nil {
17-
return presum
17+
return s
1818
}
19-
return dfs(root.Left, presum) + dfs(root.Right, presum)
19+
return dfs(root.Left, s) + dfs(root.Right, s)
2020
}
2121
return dfs(root, 0)
2222
}

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

+2-2
Original file line numberDiff line numberDiff line change
@@ -18,11 +18,11 @@ public int sumNumbers(TreeNode root) {
1818
return dfs(root, 0);
1919
}
2020

21-
private int dfs(TreeNode root, int presum) {
21+
private int dfs(TreeNode root, int s) {
2222
if (root == null) {
2323
return 0;
2424
}
25-
int s = presum * 10 + root.val;
25+
s = s * 10 + root.val;
2626
if (root.left == null && root.right == null) {
2727
return s;
2828
}

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

+21
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* function TreeNode(val, left, right) {
4+
* this.val = (val===undefined ? 0 : val)
5+
* this.left = (left===undefined ? null : left)
6+
* this.right = (right===undefined ? null : right)
7+
* }
8+
*/
9+
/**
10+
* @param {TreeNode} root
11+
* @return {number}
12+
*/
13+
var sumNumbers = function (root) {
14+
function dfs(root, s) {
15+
if (!root) return 0;
16+
s = s * 10 + root.val;
17+
if (!root.left && !root.right) return s;
18+
return dfs(root.left, s) + dfs(root.right, s);
19+
}
20+
return dfs(root, 0);
21+
};

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

+3-3
Original file line numberDiff line numberDiff line change
@@ -5,11 +5,11 @@
55
# self.left = left
66
# self.right = right
77
class Solution:
8-
def sumNumbers(self, root: TreeNode) -> int:
9-
def dfs(root, presum):
8+
def sumNumbers(self, root: Optional[TreeNode]) -> int:
9+
def dfs(root, s):
1010
if root is None:
1111
return 0
12-
s = 10 * presum + root.val
12+
s = s * 10 + root.val
1313
if root.left is None and root.right is None:
1414
return s
1515
return dfs(root.left, s) + dfs(root.right, s)

0 commit comments

Comments
 (0)