Solution 1
本题没有什么难度,就是要求遍历整个树,导出所有的路径,并将对应的数字加和。
但是一个小问题是,我采用了不同的分支逻辑,消耗时间是不一样的。
一开始我的逻辑是:
- value更新
- 如果叶子节点,更新加和结果,向上返回
- 如果不是,则对非空的分支向下递归
调整的逻辑是:
- 如果节点非空,直接返回
- value更新
- 如果叶子节点,更新加和结果,向上返回
- 对左右分支进行递归
个人认为本质上没有区别(甚至第一个思路的递归数目还会少一些)但是时间差异还是很大的,玄学?
- 时间复杂度: O ( N ) O(N) O(N),其中 N N N为树中的节点个数,遍历所有节点
- 空间复杂度: O ( N ) O(N) O(N),其中 N N N为树中的节点个数,递归过程中的函数占用,最坏情况下全偏树
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int sumNumbers(TreeNode* root) {
dfs(root, 0);
return ans;
}
private:
int ans = 0;
void dfs(TreeNode* node, int value) {
if (node == nullptr) {
return;
}
value = value * 10 + node->val;
if (node->left == nullptr && node->right == nullptr) {
ans += value;
return;
} else {
dfs(node->left, value);
dfs(node->right, value);
}
}
};
Solution 2
Solution 1的Python实现
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def sumNumbers(self, root: Optional[TreeNode]) -> int:
ans = 0
def dfs(node: Optional[TreeNode], value: int) -> None:
nonlocal ans
if node is None: return
value = value * 10 + node.val
if node.left is None and node.right is None:
ans += value
return
else:
dfs(node.left, value)
dfs(node.right, value)
# value = value * 10 + node.val
# if node.left is None and node.right is None:
# ans += value
# return
# if node.left is not None:
# dfs(node.left, value)
# if node.right is not None:
# dfs(node.right, value)
dfs(root, 0)
return ans