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.

翻译一遍吧：

    给定一个二叉树，每个元素都是从0到9的数字。 每一个从根节点到叶子节点都能计算出一个整数。

例如：如果从根节点至叶子节点路径是 1->2->3，那么这个整数就是3+2*10+1*100 = 123；

例如,

    1
   / \
  2   3

路径 1->2 表示 12.
路径 1->3 表示 13.

所以结果是= 12 + 13 = 25.

分析：

此题本看上去容易，实际做才发现有玄机啊。

通常对于树，要读树上的数据，会用到递归， 而需要层次遍历的时候，会用到队列。而本题不能直接用这两种方法。

   1.本题不能使用递归：

       因为，子树也有多条路径，对应有多个值，所以你递归的话返回值不好办。

       即使你算出子树的值，你需要确定当前节点处于子树中路径的高度，然后才能把当前节点的值也加上去。

      另外，本题已经给出了函数的形式 int sumNumbers(TreeNode *root) ，所以这个就限制不能使用递归。

2.使用队列不方便：

     队列是用于层次遍历，我们这个题需要找到所以从根节点和叶子之间的路径，并求值。我们要的是纵向深度读取， 而队列提供的是横向的。

我想来一下午，决定采用自己的栈，并且用一块缓冲区来记录路径。

int sumNumbers(TreeNode *root)
{
        TreeNode** stack = new TreeNode*[100]; //栈
        TreeNode **path = new TreeNode*[100];  //路径
        int path_size = 0;     //路径长度
        int sp=0;              //栈大小
        int total_val = 0;     //保存结果

        TreeNode* p = root;
        if( root == NULL)return 0;       //空树返回0
        stack[sp++] = p;                 //根节点压栈
        while( sp!= 0 )                  //栈不为空，一直读数据
         {
            TreeNode* temp = stack[--sp];       //栈顶元素出栈

            //找temp的父节点在path中位置, 并把temp加入到path中.
            if(path_size == 0)                     //如果路径为空（即当前节点是根节点），则将该点加入路径
            {
                path[path_size++] = temp;
            }else
            {
                for(int i =0;i<path_size;i++)     //在path路径中找到该节点的父结点，并把该点放到父节点之后，path的长度有要修改。
                {
                    if(path[i]->left == temp || path[i]->right == temp)
                    {
                        path[i+1] = temp;
                        path_size = i+2;
                        break;
                    }
                }
            }
            //左右子节点都要入栈
             if( temp->right!= NULL)
             {
                stack[sp++] = temp->right;
             }
             if( temp->left !=NULL)
             {
                stack[sp++] = temp->left;
             }
             if(temp->right == NULL && temp->left == NULL) //如果该点是叶子，那么我们要计算从该路径到根节点的值了。
             {
                int sum_temp = 0; //记录该路径的值
                for(int i=0;i<path_size;i++)
                {
                    cout<<path[i]->val<<endl;
                    sum_temp = 10*sum_temp + path[i]->val;
                }
                total_val += sum_temp; //统计所有路径的值
             }
        }
       delete stack;
       delete path;
       return total_val;

}

至于复杂读：

     主循环应该是N次，而主循环中的for语句是log（N），总的时间复杂度是O（N*log（N））

     存储的话，分配来log（N）