LeetCode - 解题笔记 - 129 - Sum Root to Leaf Numbers

Solution 1

本题没有什么难度，就是要求遍历整个树，导出所有的路径，并将对应的数字加和。

但是一个小问题是，我采用了不同的分支逻辑，消耗时间是不一样的。

一开始我的逻辑是：

1. value更新
2. 如果叶子节点，更新加和结果，向上返回
3. 如果不是，则对非空的分支向下递归

调整的逻辑是：

1. 如果节点非空，直接返回
2. value更新
3. 如果叶子节点，更新加和结果，向上返回
4. 对左右分支进行递归

个人认为本质上没有区别（甚至第一个思路的递归数目还会少一些）但是时间差异还是很大的，玄学？

• 时间复杂度：$O(N)$，其中$N$为树中的节点个数，遍历所有节点
• 空间复杂度：$O(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