求根到叶子节点数字之和(Java)

给定一个二叉树，它的每个结点都存放一个 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.

package com.loo;

import java.util.LinkedList;
import java.util.Queue;

public class SumTreeNumbers {

    public static void main(String[] args) {
        TreeNode root1 = new TreeNode(1);
        TreeNode left = new TreeNode(2);
        TreeNode right = new TreeNode(3);
        root1.left = left;
        root1.right = right;
        System.out.println(getSumTreeNumbers(root1));
        System.out.println(bfs(root1));
        TreeNode root2 = new TreeNode(4);
        TreeNode left21 = new TreeNode(9);
        TreeNode right21 = new TreeNode(0);
        TreeNode left22 = new TreeNode(5);
        TreeNode left23 = new TreeNode(1);
        root2.left = left21;
        root2.right = right21;
        left21.left = left22;
        left21.right = left23;
        System.out.println(getSumTreeNumbers(root2));
        System.out.println(bfs(root2));
    }
    
    public static int getSumTreeNumbers(TreeNode root) {
        return dfs(root , 0);
    }
    
    public static int dfs(TreeNode root , int prevSum) {
        if (root == null) {
            return 0;
        }
        int sum = prevSum * 10 + root.value;
        if (root.left == null && root.right == null) {
            return sum;
        } else {
            return dfs(root.left , sum) + dfs(root.right , sum);
        }
    }
    
    public static int bfs(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int sum = 0;
        Queue<TreeNode> nodeQueue = new LinkedList<TreeNode>();
        Queue<Integer> sumQueue = new LinkedList<Integer>();
        nodeQueue.offer(root);
        sumQueue.offer(root.value);
        while (!nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.poll();
            int num = sumQueue.poll();
            TreeNode left = node.left;
            TreeNode right = node.right;
            if (left == null && right == null) {
                sum += num;
            } else {
                if (left!=null) {
                    nodeQueue.offer(left);
                    sumQueue.offer(num*10+left.value);
                }
                if (right!=null) {
                    nodeQueue.offer(right);
                    sumQueue.offer(num*10+right.value);
                }
            }
        }
        return sum;
    }
    
    static class TreeNode {
        int value;
        TreeNode left;
        TreeNode right;
        TreeNode(int v) {
            value = v;
        }
    }

}