Sum Root to Leaf Numbers - Practice Coding Problems

Sum Root to Leaf Numbers - Problem

Imagine you have a binary tree where each node contains a single digit from 0 to 9. This tree represents multiple numbers formed by following paths from the root to each leaf node.

For example, if you have a path that goes 1 → 2 → 3, this represents the number 123. Your task is to find all such root-to-leaf paths and return the sum of all numbers they represent.

Goal: Calculate the total sum of all numbers formed by root-to-leaf paths in the binary tree.

Input: The root node of a binary tree containing digits 0-9

Output: An integer representing the sum of all root-to-leaf numbers

Input & Output

example_1.py — Basic Tree

$ Input: root = [1,2,3]

› Output: 25

💡 Note: Root-to-leaf paths are 1->2 (forms number 12) and 1->3 (forms number 13). Sum: 12 + 13 = 25

example_2.py — Deeper Tree

$ Input: root = [4,9,0,5,1]

› Output: 1026

💡 Note: Root-to-leaf paths: 4->9->5 (495), 4->9->1 (491), and 4->0 (40). Sum: 495 + 491 + 40 = 1026

example_3.py — Single Node

$ Input: root = [9]

› Output: 9

💡 Note: Single node tree has only one root-to-leaf path containing just 9

Visualization

Tap to expand

Understanding the Visualization

Start at the Root

Begin at the eldest ancestor with phone number starting as 0

Build Number Incrementally

As you move to each descendant, multiply current number by 10 and add their digit

Collect at Leaf Nodes

When you reach someone with no children, you have a complete phone number

Sum All Numbers

Add all collected phone numbers to get the final sum

Key Takeaway

🎯 Key Insight: Instead of collecting all paths first, we build each number incrementally during DFS traversal and sum them immediately at leaf nodes, achieving optimal O(n) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in the tree

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(log n) for balanced tree

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 1000]
0 ≤ Node.val ≤ 9
The depth of the tree will not exceed 10
All test cases guarantee the answer fits in a 32-bit integer

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses DFS traversal to build numbers on-the-fly during tree exploration. Key insight: multiply current number by 10 and add the node's digit at each step. When reaching a leaf node, add the complete number to the running sum. This achieves O(n) time and O(h) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Number Building (Optimal)	O(n)	O(h)	Build numbers during DFS traversal and sum at leaf nodes

DFS with Number Building (Optimal) — Algorithm Steps

Start DFS from root with current number = 0 and total sum = 0
At each node, update current number = current_number * 10 + node.val
If current node is a leaf, add current number to total sum
Otherwise, recursively process left and right children
Return the accumulated sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin with current_number = 0, add root value

Multiply and Add

At each node: current_number = current_number * 10 + node.val

Leaf Processing

When reaching leaf, add complete number to sum

Backtrack

Return to parent and continue with other branches

Code -

solution.c — C

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

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

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

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in the tree

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(log n) for balanced tree

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 1000]
0 ≤ Node.val ≤ 9
The depth of the tree will not exceed 10
All test cases guarantee the answer fits in a 32-bit integer

89.0K Views

High 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

DFS with Number Building (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler