第57题 Sum Root to Leaf Numbers

最新推荐文章于 2022-04-08 10:01:02 发布

amberFeb

最新推荐文章于 2022-04-08 10:01:02 发布

阅读量344

点赞数

CC 4.0 BY-SA版权

分类专栏： CodeReview CodeReview->Tree

本文链接：https://blog.youkuaiyun.com/amberFeb/article/details/45446001

CodeReview 同时被 2 个专栏收录

76 篇文章

订阅专栏

CodeReview->Tree

9 篇文章

订阅专栏

本文详细介绍了如何使用Java算法解决二叉树问题，具体为求解所有从根节点到叶子节点的数字路径所组成的数值之和。提供了两种解决方案：一种是后序遍历的非递归方法，另一种是递归方法。通过实例代码解释了算法实现过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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.

Hide Tags

Tree Depth-first Search

Solution in Java 1: 后序遍历+非递归

<span style="font-size:18px;">/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int sumNumbers(TreeNode root) {
        if(root==null) return 0;
        int sum = 0;
        int curSum =0;
        int digit = 0;
        Stack<TreeNode> path = new Stack<TreeNode>();
        Stack<Boolean> ifVisited = new Stack<Boolean>();
        while(root!=null || !path.empty()){
            while(root!=null){
                curSum = curSum*10+root.val;
                digit++;
                path.push(root);
                ifVisited.push(false);
                root = root.left;
            }
            //loop until root is null, there is no left child;
            
            while(ifVisited.peek()&&!ifVisited.empty()){
                
            }
            if(!path.empty()){
                TreeNode curNode = path.peek();
                if(curNode.right==null && curNode.left==null){    //no left child and no right child=> leafnode
                    path.pop(); 
                    ifVisited.pop();
                    sum = sum+ curSum;
                    curSum = curSum/10;
                    digit--;
                }
                else{
                    if(ifVisited.peek()){    //the top node has already been visited the right subtree
                        path.pop();
                        ifVisited.pop();
                        curSum= curSum/10;
                        digit--;
                    }
                    else{
                        ifVisited.pop();
                        ifVisited.push(true);
                        root = curNode.right;
                    }
                }
            }
        }
        return sum;
        
    }
}</span>

Note: 必须要用后续遍历，是因为如果是前序或者中序，在未遍历右子树的时候，保存之前路径的信息（包括该右子树的根结点信息，值等）就要被更新了，在该题中就行不通的。

Solution in Jav a 2: 递归的方法

<span style="font-size:18px;">/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
 
    public int sumNumbers(TreeNode root) {
        if(root==null) return 0;
        
        return getSum(root,  0);
    }
    public int getSum(TreeNode root, int cur){
        if(root.left==null&& root.right==null) return cur*10+root.val;
        int result =0;
        if(root.left!=null)  result+=getSum(root.left, cur*10+root.val);
        if(root.right!=null) result+=getSum(root.right, cur*10+root.val);
        return result;
    }
}</span>