Deepest Leaves Sum - Practice Coding Problems

Deepest Leaves Sum - Problem

Sum of Deepest Leaves in Binary Tree

Imagine you have a binary tree where leaves at different levels contain valuable treasures. Your mission is to find all leaves that are at the deepest level (farthest from the root) and calculate the total sum of their values.

📋 Task: Given the root of a binary tree, return the sum of values of its deepest leaves.

🎯 Goal: Identify the maximum depth of the tree, then sum all leaf nodes that exist at this maximum depth.

💡 Example: In a tree with depths 0, 1, 2, if the deepest leaves at level 2 have values [4, 5, 6], return 15.

Input & Output

example_1.py — Python

$ Input: root = [1,2,3,4,5,null,6,7,null,null,null,null,8]

› Output: 15

💡 Note: The tree has maximum depth 3. Nodes at depth 3 are [7, 8]. Sum = 7 + 8 = 15.

example_2.py — Python

$ Input: root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]

› Output: 19

💡 Note: The deepest leaves are at depth 4. The deepest leaves are [9, 1, 4, 5]. Sum = 9 + 1 + 4 + 5 = 19.

example_3.py — Python

$ Input: root = [1]

› Output: 1

💡 Note: Edge case: single node tree. The root is the only and deepest leaf with value 1.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
1 ≤ Node.val ≤ 100
All node values are positive integers

Visualization

Tap to expand

Understanding the Visualization

Start at Ground Floor

Begin at the root (ground floor) and start exploring deeper floors

Track Highest Floor

As we visit each floor, keep track of the highest floor number reached

Collect Treasures

When we find a new highest floor, reset our treasure count. If we find more rooms on the same highest floor, add to our treasure count

Final Count

After visiting all rooms, return the total treasure from the highest floor

Key Takeaway

🎯 Key Insight: By tracking both the maximum depth and sum in a single traversal, we eliminate the need for multiple passes through the tree, achieving optimal O(n) time complexity.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24 Apple 18

The optimal solution uses a single-pass DFS approach with state tracking. As we traverse the tree, we maintain both the maximum depth seen so far and the sum of nodes at that depth. When we discover a deeper level, we reset the sum and update the maximum depth. This achieves O(n) time complexity with only one tree traversal, making it significantly more efficient than the brute force two-pass approach.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass DFS (Brute Force)	O(2n) = O(n)	O(h)	Find max depth first, then traverse again to sum nodes at that depth
Single-Pass DFS (Optimal)	O(n)	O(h)	Track max depth and sum simultaneously in one traversal

Two-Pass DFS (Brute Force) — Algorithm Steps

First DFS traversal to find the maximum depth of the tree
Second DFS traversal to sum all nodes at the maximum depth
Return the accumulated sum

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass - Find Max Depth

Traverse entire tree to find maximum depth (3 in this example)

Second Pass - Sum at Max Depth

Traverse again, sum only nodes at depth 3: 7 + 4 = 11

Code -

solution.c — C

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

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

int findMaxDepth(struct TreeNode* node, int depth) {
    if (!node) return depth - 1;
    int leftDepth = findMaxDepth(node->left, depth + 1);
    int rightDepth = findMaxDepth(node->right, depth + 1);
    return leftDepth > rightDepth ? leftDepth : rightDepth;
}

int sumAtDepth(struct TreeNode* node, int currentDepth, int targetDepth) {
    if (!node) return 0;
    if (currentDepth == targetDepth) return node->val;
    return sumAtDepth(node->left, currentDepth + 1, targetDepth) + sumAtDepth(node->right, currentDepth + 1, targetDepth);
}

int deepestLeavesSum(struct TreeNode* root) {
    int maxDepth = findMaxDepth(root, 0);
    return sumAtDepth(root, 0, maxDepth);
}

int main() {
    printf("Solution ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2n) = O(n)

Two complete DFS traversals of all n nodes

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, worst case O(n) for skewed tree

✓ Linear Space

58.9K Views

Medium Frequency

~18 min Avg. Time

2.8K 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

Two-Pass DFS (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler