二叉树根节点到叶子节点的所有路径和

题目

描述
给定一个二叉树的根节点root，该树的节点值都在数字
0−9 之间，每一条从根节点到叶子节点的路径都可以用一个数字表示。
1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点
2.叶子节点是指没有子节点的节点
3.路径只能从父节点到子节点，不能从子节点到父节点
4.总节点数目为n
数据范围：节点数 0≤n≤100，保证结果在32位整型范围内
进阶：空间复杂度 O(n)，时间复杂度 O(n)

思路

采用深度优先遍历的思想，用一个栈来遍历存储每一个节点，另一个来更新每个路径的值的和。

代码

python版本：

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @return int整型
#
class Solution:
    def sumNumbers(self , root: TreeNode) -> int:
        # write code here
        res = 0
        if(root==None):
            return res
        storage_node = [root]
        storage_val = [root.val]
        while(len(storage_node)):
            node = storage_node.pop(0)
            val = storage_val.pop(0)
            if(node.left==None and node.right==None):
                res += val
            else:
                if(node.left != None):
                    storage_node.append(node.left)
                    storage_val.append(val*10+node.left.val)
                if(node.right != None):
                    storage_node.append(node.right)
                    storage_val.append(val*10+node.right.val)
        return res

c++版本：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param root TreeNode类 
     * @return int整型
     */
    int sumNumbers(TreeNode* root) {
        // write code here
        stack<int> storage_val;
        stack<TreeNode*> storage_node;
        int res = 0;
        if(root==nullptr){
            return res;
        }
        storage_node.push(root);
        storage_val.push(root->val);
        while(!storage_node.empty()){
            TreeNode *node = storage_node.top();
            storage_node.pop();
            int value = storage_val.top();
            storage_val.pop();
            if(node->left==nullptr&&node->right==nullptr){
                res += value;
            }else{
                if(node->left != nullptr){
                    storage_node.push(node->left);
                    storage_val.push(value*10 + node->left->val);
                }
                if(node->right != nullptr){
                    storage_node.push(node->right);
                    storage_val.push(value*10 + node->right->val);
                }
            }
        }
        return res;
    }
};