求根到叶子节点数字之和

1.问题描述

给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。

例如，从根到叶子节点路径 1->2->3 代表数字 123。

计算从根到叶子节点生成的所有数字之和。

说明: 叶子节点是指没有子节点的节点。

示例 1:

输入: [1,2,3]
1
/ \
2 3
输出: 25
解释:
从根到叶子节点路径 1->2 代表数字 12.
从根到叶子节点路径 1->3 代表数字 13.
因此，数字总和 = 12 + 13 = 25.

示例 2:

输入: [4,9,0,5,1]
4
/ \
9 0
 / \
5 1
输出: 1026
解释:
从根到叶子节点路径 4->9->5 代表数字 495.
从根到叶子节点路径 4->9->1 代表数字 491.
从根到叶子节点路径 4->0 代表数字 40.
因此，数字总和 = 495 + 491 + 40 = 1026.

2.求解

深度优先遍历

• 从根节点开始，遍历每个节点。每层递归要做的就是再次调用递归函数计算左右子节点之和
• 递归停止的条件有两个
  1. 当节点为空时，直接返回0
  2. 当节点左右子节点均为空是，说明遍历至终点，此时返回sum

代码如下

/*
 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
 * 内存消耗：36.2 MB, 在所有 Java 提交中击败了87.91% 的用户
 * */
public int sumNumbers(TreeNode root) {
    return dfs(root, 0);
}

public int dfs(TreeNode root,int prevSum){
    //当前节点为空，返回0
    if(root == null){
        return 0;
    }
    //不为空，计算sum
    int sum = prevSum * 10 + root.val;
    //左右节点为空，说明已经到达终点，返回sum
    if(root.left == null && root.right == null){
        return sum;
    }
    //左右节点有非空，继续计算sum
    return dfs(root.left,sum) + dfs(root.right,sum);
}

• 时间、空间复杂度均为O(n)

广度优先搜索

• 维护两个队列，一个存储节点，另一个存储目前已经计算的sum
• 每次先取出一个节点，若左右节点不为空，将左右节点放入节点队列，将当前节点的值乘10分别加左节点和右节点入sum队列

代码如下

/*
 * 执行用时：1 ms, 在所有 Java 提交中击败了31.04% 的用户
 * 内存消耗：36.5 MB, 在所有 Java 提交中击败了69.26% 的用户
 * */
public int sumNumbers(TreeNode root) {
    if(root == null){
        return 0;
    }
    int sum = 0;
    Queue<TreeNode> nodeQueue = new LinkedList<>();
    Queue<Integer> numQueue = new LinkedList<>();
    nodeQueue.offer(root);
    numQueue.offer(root.val);
    while(!nodeQueue.isEmpty()){
        TreeNode node = nodeQueue.poll();
        int num = numQueue.poll();
        TreeNode left = node.left,right = node.right;
        if(left == null && right == null){
            sum += num;
        }else {
            if(left != null){
                nodeQueue.offer(left);
                numQueue.offer(num * 10 + left.val);
            }
            if(right != null){
                nodeQueue.offer(right);
                numQueue.offer(num * 10 + right.val);
            }
        }
    }
    return sum;
}

• 时间、空间复杂度均为O(n)