【Java】【LeetCode】129. 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.

Note: A leaf is a node with no children.

Example:

Input: [1,2,3]
    1
   / \
  2   3
Output: 25
Explanation:
The root-to-leaf path 1->2 represents the number 12.
The root-to-leaf path 1->3 represents the number 13.
Therefore, sum = 12 + 13 = 25.

Example 2:

Input: [4,9,0,5,1]
    4
   / \
  9   0
 / \
5   1
Output: 1026
Explanation:
The root-to-leaf path 4->9->5 represents the number 495.
The root-to-leaf path 4->9->1 represents the number 491.
The root-to-leaf path 4->0 represents the number 40.
Therefore, sum = 495 + 491 + 40 = 1026.

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

public class SumRoottoLeafNumbers
{

    public static void main(String[] args)
    {
        /**
         * Example:
         * Input: [1,2,3]
         * 1
         * / \
         * 2 3
         * Output: 25
         * Explanation:
         * The root-to-leaf path 1->2 represents the number 12.
         * The root-to-leaf path 1->3 represents the number 13.
         * Therefore, sum = 12 + 13 = 25.
         */
        TreeNode root1 = new TreeNode(1);
        TreeNode tn12 = new TreeNode(2);
        TreeNode tn13 = new TreeNode(3);
        root1.left = tn12;
        root1.right = tn13;
        System.out.println(sumNumbers(root1));
        /**
         * Input: [4,9,0,5,1]
         * 4
         * / \
         * 9 0
         * / \
         * 5 1
         * Output: 1026
         * Explanation:
         * The root-to-leaf path 4->9->5 represents the number 495.
         * The root-to-leaf path 4->9->1 represents the number 491.
         * The root-to-leaf path 4->0 represents the number 40.
         * Therefore, sum = 495 + 491 + 40 = 1026.
         */
        TreeNode root2 = new TreeNode(4);
        TreeNode tn29 = new TreeNode(9);
        TreeNode tn20 = new TreeNode(0);
        TreeNode tn25 = new TreeNode(5);
        TreeNode tn21 = new TreeNode(1);
        root2.left = tn29;
        root2.right = tn20;
        tn29.left = tn25;
        tn29.right = tn21;
        System.out.println(sumNumbers(root2));
    }

    public static int sumNumbers(TreeNode root)
    {
        if (root == null)
        {
            return 0;
        }
        int result = 0;
        Queue<TreeNode> nodeQueue = new LinkedList<TreeNode>();
        Queue<Integer> sumQueue = new LinkedList<Integer>();
        nodeQueue.offer(root);
        sumQueue.offer(root.val);
        while (!nodeQueue.isEmpty())
        {
            root = nodeQueue.poll();
            int sum = sumQueue.poll();
            if (root.left == null && root.right == null)
            {
                result += sum;
            }
            if (root.left != null)
            {
                nodeQueue.offer(root.left);
                sumQueue.offer(root.left.val + sum * 10);
            }
            if (root.right != null)
            {
                nodeQueue.offer(root.right);
                sumQueue.offer(root.right.val + sum * 10);
            }
        }
        return result;
    }

}