Sum of Root To Leaf Binary Numbers - Practice Coding Problems

Sum of Root To Leaf Binary Numbers - Problem

Imagine you're walking through a binary tree where each node contains either a 0 or 1. Every path from the root to a leaf represents a binary number, where the most significant bit is at the root.

Your mission: Calculate the sum of all binary numbers formed by root-to-leaf paths.

For example, if you traverse the path 1 → 0 → 1, this represents the binary number 101, which equals 5 in decimal. You need to find all such paths and sum up their decimal values.

The tree structure guarantees that each path creates a unique binary number, and all results fit within a 32-bit integer.

Input & Output

example_1.py — Python

$ Input: root = [1,0,1,0,1,0,1]

› Output: 22

💡 Note: The tree has 4 paths: (1->0->0)=4, (1->0->1)=5, (1->1->0)=6, (1->1->1)=7. Sum: 4+5+6+7=22

example_2.py — Python

$ Input: root = [0]

› Output: 0

💡 Note: Single node tree with value 0 represents binary '0' which equals decimal 0

example_3.py — Python

$ Input: root = [1,1,0,1,1,0,1]

› Output: 32

💡 Note: Multiple paths: (1->1->1)=7, (1->1->1)=7, (1->0->0)=4, (1->0->1)=5. But actual tree structure gives different paths totaling 32

Constraints

The number of nodes in the tree is in the range [1, 1000]
Node.val is either 0 or 1
All answers fit within a 32-bit integer
Tree height will not exceed 10³ levels

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at root with accumulated value = 0

Build Route Code

At each node, double current value and add node's bit: value = value * 2 + bit

Reach Destination

When reaching a leaf (destination), record the final route code

Sum All Routes

Add up all unique route codes to get the final answer

Key Takeaway

🎯 Key Insight: Binary-to-decimal conversion can be done incrementally during tree traversal using bit shifting: `value = value * 2 + bit`

Asked in

a Amazon 45 ⊞ Microsoft 35 G Google 30 f Meta 20

The optimal solution uses DFS traversal with on-the-fly decimal calculation. Instead of storing binary strings, we build decimal values incrementally using the formula: new_value = current_value * 2 + node.val. This achieves O(n) time complexity and O(h) space complexity where h is the tree height.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized DFS (Build Value On-The-Fly)	O(n)	O(h)	Calculate decimal values during traversal without storing intermediate strings

Optimized DFS (Build Value On-The-Fly) — Algorithm Steps

Start DFS with current decimal value = 0
For each node: new_value = current_value * 2 + node.val
When reaching a leaf, add the current value to sum
Backtrack and continue with other paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Initialize current value to 0, visit root with value 1

Build Value

At each node: new_value = current_value * 2 + node.val

Accumulate at Leaves

When reaching leaves, add current value to total sum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int dfs(struct TreeNode* node, int currentValue) {
    if (!node) return 0;
    
    currentValue = currentValue * 2 + node->val;
    
    if (!node->left && !node->right) {
        return currentValue;
    }
    
    return dfs(node->left, currentValue) + dfs(node->right, currentValue);
}

int sumRootToLeaf(struct TreeNode* root) {
    return dfs(root, 0);
}

// Stack-based iterative approach
typedef struct {
    struct TreeNode* node;
    int value;
} StackItem;

int sumRootToLeafIterative(struct TreeNode* root) {
    if (!root) return 0;
    
    StackItem stack[1000];
    int top = 0;
    int total = 0;
    
    stack[top++] = (StackItem){root, 0};
    
    while (top > 0) {
        StackItem current = stack[--top];
        int newValue = current.value * 2 + current.node->val;
        
        if (!current.node->left && !current.node->right) {
            total += newValue;
        } else {
            if (current.node->right) {
                stack[top++] = (StackItem){current.node->right, newValue};
            }
            if (current.node->left) {
                stack[top++] = (StackItem){current.node->left, newValue};
            }
        }
    }
    
    return total;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during DFS traversal

✓ Linear Growth

Space Complexity

O(h)

Only recursion stack space, where h is the height of the tree

✓ Linear Space

95.0K Views

Medium Frequency

~15 min Avg. Time

2.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimized DFS (Build Value On-The-Fly) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler