【LeetCode】129. Sum Root to Leaf Numbers (2 solutions)

Sum Root to Leaf Numbers

Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number.

An example is the root-to-leaf path 1->2->3 which represents the number 123.

Find the total sum of all root-to-leaf numbers.

For example,

    1
   / \
  2   3

The root-to-leaf path 1->2 represents the number 12.
The root-to-leaf path 1->3 represents the number 13.

Return the sum = 12 + 13 = 25.

每到达一个根节点，就代表一个路径访问完成，将和加入总和。

解法一：

树结构用递归是最容易的，每递归一层，上层的部分和需要乘以10在做加法。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int sumNumbers(TreeNode *root) {
        int Sum = ;
        Helper(root, , Sum);
        return Sum;
    }
    void Helper(TreeNode* root, int partSum, int& Sum)
    {
        if(root == NULL)
            return;
        else if(root->left == NULL && root->right == NULL)  //add this path
            Sum += (*partSum+root->val);
        else
        {
            Helper(root->left, *partSum+root->val, Sum);
            Helper(root->right, *partSum+root->val, Sum);
        }
    }
};

解法二：

非递归方法，使用栈存放当前的路径进行深度搜索，并设置部分和记录栈中的数值。

结合进栈与出栈进行部分和调整：

进栈：部分和*10+当前值

出栈：(部分和-当前值)/10

如果遍历到叶节点，则将部分和加入总和。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int sumNumbers(TreeNode* root) {
        if(root == NULL)
            return ;
        int ret = ;
        int cur = ;
        stack<TreeNode*> stk;
        unordered_map<TreeNode*, bool> visited;
        stk.push(root);
        visited[root] = true;
        cur += root->val;
        while(!stk.empty())
        {
            TreeNode* top = stk.top();
            if(top->left != NULL && visited[top->left] == false)
            {
                stk.push(top->left);
                visited[top->left] = true;
                cur = cur* + top->left->val;
                continue;
            }
            if(top->right != NULL && visited[top->right] == false)
            {
                stk.push(top->right);
                visited[top->right] = true;
                cur = cur* + top->right->val;
                continue;
            }
            if(top->left == NULL && top->right == NULL)
            {
                ret += cur;
            }
            stk.pop();
            cur = (cur - top->val) / ;
        }
        return ret;
    }
};