LeetCode(129)SumRoottoLeafNumbers

题目如下：

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.

分析如下:

用递归是比较自然的想法，一开始写得很乱。有几个关键问题没想清楚。(1) 参数使用引用型吗,是一定需要用还是可用可不用还是一定不能用？(2) 节点都有哪些情况?(3)递归什么时候返回？

节点可能出现的情况:
(1)左孩子或者右孩子两个都为NULL(叶节点)，此时递归返回。
(2)左孩子或者右孩子某一个为NULL，此时继续推进下一层调用，只是在下一层中，会发现有一个为NULL节点，走到NULL节点当然应该返回了。
(3)左孩子或者右孩子都不为NULL，此时继续推进下一层的调用。
虽然(2)和(3)都是继续推进下一层的调用，但是由于(2)会遇到NULL节点，对于这个特殊情况，需要写句话处理一下。
从上面的分析可以看出来，没有使用引用的必要性。

我的代码:

/**
 * 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) {
        if(root==NULL)
            return 0;
        sum=sum*10+root->val;
        if(root->left==NULL&&root->right==NULL)
            return sum;
        return _sumNumbers(root->left,sum) + _sumNumbers(root->right,sum);
    }
    
    int sumNumbers(TreeNode *root) {
        return _sumNumbers(root, 0);
    }
};

虽然上面这个代码没有使用引用型参数(并且int sum在上面的代码中不能写为引用型代码)，但是实际上，稍微修改一下，可以使用引用型参数。参考了 这里。

// 如果使用引用型的参数
class Solution {
public:
 
    void dfs(TreeNode* root,int cur, int &res){
        if (root->left==NULL && root->right==NULL){
            cur=cur*10+root->val;
            res+=cur;
        }else{
            cur=cur*10+root->val;
            if (root->left){
                dfs(root->left,cur,res);
            }
            if (root->right){
                dfs(root->right,cur,res);
            }
        }
    }
    int sumNumbers(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int res=0;
        if (!root){return res;}
        dfs(root,0,res);
        return res;
    }
};

如果把这个问题扩展一下，在链表中，也有类似问题。如果一个链表是1->2->3->4->5，那么它将表达12345这个数。写程序表达这样的转换。

    int _sumLinkedList(ListNode* node, int sum){
        if(node==NULL)
            return sum;
        sum=sum*10+node->val;
        return _sumLinkedList(node->next,sum);
    }
    
    int sumLinkedList(ListNode* root){
        return _sumLinkedList(root,0);
    }

小结:

(1)注意下面这个写法

    int _sumNumbers(TreeNode *root, int sum) {
          ......
          return _sumNumbers(root->left,sum) + _sumNumbers(root->right,sum);
          ......
    }

参考资料:

(1 ) Yu's Coding Garden

update: 2014-11-13

class Solution {
private:
    int my_sumNumbers(TreeNode *root, int cur_sum) {
        if (root == NULL) 
            return 0;
        if (root->left == NULL && root->right == NULL)
            return cur_sum * 10 + root->val;
        return my_sumNumbers(root->left, cur_sum*10 + root->val) + my_sumNumbers(root->right, cur_sum*10 + root->val);
    }
public:
    int sumNumbers(TreeNode *root) {
        return my_sumNumbers(root, 0);
    }
};