leetcode hot150第129题，求根节点到叶子节点的数字之和

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。

每条从根节点到叶节点的路径都代表一个数字：

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

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

叶节点 是指没有子节点的节点。

先附上TreeNode，这里我自己定义一个buildTree函数，通过integer类型的数组，层序遍历的顺序来初始化树。

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

public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;

    TreeNode() {
    }

    public TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }

    /**
     * 通过层序遍历创建树
     */
    public static TreeNode buildTree(Integer[] array) {
        if (array == null || array.length == 0) {
            return null;
        }

        TreeNode root = new TreeNode(array[0]);
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        int i = 1;
        while (i < array.length) {
            TreeNode currentNode = queue.poll();
            if (i < array.length && array[i] != null) {
                currentNode.left = new TreeNode(array[i]);
                queue.offer(currentNode.left);
            }
            i++;
            if (i < array.length && array[i] != null) {
                currentNode.right = new TreeNode(array[i]);
                queue.offer(currentNode.right);
            }
            i++;
        }

        return root;
    }

    /**
     * 层序遍历
     */
    public static void levelOrder(TreeNode root) {
        if (root == null) {
            return;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            TreeNode currentNode = queue.poll();
            System.out.print(currentNode.val + " ");

            if (currentNode.left != null) {
                queue.offer(currentNode.left);
            }

            if (currentNode.right != null) {
                queue.offer(currentNode.right);
            }
        }

        for (TreeNode treeNode : queue) {
            System.out.print(treeNode.val + " ");
        }
    }
}

 这样树就可以轻松创建出来，可以在自己的ide上debug，这在leetcode上需要开会员。

public class no_129 {
    public static void main(String[] args) {

        TreeNode t = TreeNode.buildTree(new Integer[]{4, 9, 0, 5, 1});
        int re = sumNumbers(t);
        System.out.println(re);

    }

    public static int sumNumbers(TreeNode root) {
        return dfs(root, 0);
    }

    public static int dfs(TreeNode node, int currentSum) {
        if (node == null) return 0;

        currentSum = currentSum * 10 + node.val;

        if (node.left == null && node.right == null) {
            return currentSum;
        }

        int leftSum = dfs(node.left, currentSum);
        int rightSum = dfs(node.right, currentSum);

        return leftSum + rightSum;
    }
}

首先定义递归终止条件，node==null代表到了叶子节点的子节点(null)，返回0。

从上到下依次是每个节点的值乘十然后加上下一个节点的值，如果到叶子节点后，则一个分支算完，返回一个加数。

左右子树都算完之后，再返回左子树和右子树之和。