Approach: DFS shifting the running value left by one bit

def sumRootToLeaf(self, root):
    def dfs(node, cur):
        if not node: return 0
        cur = cur * 2 + node.val
        if not node.left and not node.right: return cur
        return dfs(node.left, cur) + dfs(node.right, cur)
    return dfs(root, 0)

Complexity: O(n) time, O(h) space.

Full Solution — all languages

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def sumRootToLeaf(self, root):
        def dfs(node, cur):
            if not node: return 0
            cur = cur * 2 + node.val
            if not node.left and not node.right: return cur
            return dfs(node.left, cur) + dfs(node.right, cur)
        return dfs(root, 0)

import java.util.*;
class TreeNode {
    int val;
    TreeNode left, right;
    TreeNode(int v) {
        val = v;
    }
}
class Solution {
    public int sumRootToLeaf(TreeNode root) {
        return dfs(root, 0);
    }
    private int dfs(TreeNode node, int cur) {
        if (node == null) return 0;
        cur = cur * 2 + node.val;
        if (node.left == null && node.right == null) return cur;
        return dfs(node.left, cur) + dfs(node.right, cur);
    }
}

#include <bits/stdc++.h> using namespace std;
struct TreeNode {
    int val;
    TreeNode *left, *right;
    TreeNode(int v): val(v), left(nullptr), right(nullptr) {
    }
};
class Solution {
    public: int sumRootToLeaf(TreeNode* root) {
        function<int(TreeNode*,int)> dfs = [&](TreeNode* node, int cur) -> int {
            if (!node) return 0;
            cur = cur * 2 + node->val;
            if (!node->left && !node->right) return cur;
            return dfs(node->left, cur) + dfs(node->right, cur);
        };
        return dfs(root, 0);
    }
};

/**
 * Tree node shape: { val, left, right }
 * @param {TreeNode} root
 * @return {number}
 */ var sumRootToLeaf = function(root) {
    const dfs = (node, cur) => {
        if (!node) return 0;
        cur = cur * 2 + node.val;
        if (!node.left && !node.right) return cur;
        return dfs(node.left, cur) + dfs(node.right, cur);
    };
    return dfs(root, 0);
};

Sum of Root To Leaf Binary Numbers

Example 1

Example 2

Constraints