LeetCode 1022. Sum of Root To Leaf Binary Numbers

You are given the root of a binary tree where each node has a value 0 or 1. Each root-to-leaf path represents a binary number starting with the most significant bit.

• For example, if the path is 0 -> 1 -> 1 -> 0 -> 1, then this could represent 01101 in binary, which is 13.

For all leaves in the tree, consider the numbers represented by the path from the root to that leaf. Return the sum of these numbers.

The test cases are generated so that the answer fits in a 32-bits integer.

Example 1:

Input: root = [1,0,1,0,1,0,1]
Output: 22
Explanation: (100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22

Example 2:

Input: root = [0]
Output: 0

Constraints:

• The number of nodes in the tree is in the range [1, 1000].
• Node.val is 0 or 1.

---

这题和257挺像的（LeetCode 257. Binary Tree Paths_wenyq7的博客-CSDN博客），不过这题是求二进制的值。刚开始还想着用string或者stringBuilder来存，然后进行一次进制转换，后来仔细想了一下好像可以直接通过全局变量解决，计算二进制表示就* 2 + val就行了，于是写出来的代码非常简洁了。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    int result = 0;
    public int sumRootToLeaf(TreeNode root) {
        helper(root, 0);
        return result;
    }

    private void helper(TreeNode root, int val) {
        if (root == null) {
            return;
        }
        val = val * 2 + root.val;
        if (root.left == null && root.right == null) {
            result += val;
        }
        helper(root.left, val);
        helper(root.right, val);
    }
}

 看了看别人写的，也可以不用全局变量，直接在helper里return int。这里注意，当root == null的时候，return的应该是0而不是val，因为这里return的是以当前root开始的子树的result。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int sumRootToLeaf(TreeNode root) {
        return helper(root, 0);
    }

    private int helper(TreeNode root, int val) {
        if (root == null) {
            return 0;
        }
        val = val * 2 + root.val;
        if (root.left == null && root.right == null) {
            return val;
        } else {
            return helper(root.left, val) + helper(root.right, val);
        }
    }
}

---

迭代也比较好写。刚开始踩了个坑，把vals stack里push进去了root.val，然后出来怎么都不对，最后才发现应该push进0……

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int sumRootToLeaf(TreeNode root) {
        int result = 0;
        Deque<TreeNode> stack = new ArrayDeque<>();
        Deque<Integer> vals = new ArrayDeque<>();
        stack.push(root);
        vals.push(0);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            int val = vals.pop();
            val = val * 2 + node.val;
            if (node.left == null && node.right == null) {
                result += val;
            } else {
                if (node.left != null) {
                    stack.push(node.left);
                    vals.push(val);
                }
                if (node.right != null) {
                    stack.push(node.right);
                    vals.push(val);
                }
            }
        }
        return result;
    }
}