Deepest Leaves Sum

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

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

✓ Optimized

⏱️ Time: N/A Space: N/A

Single-Pass DFS (Optimal)

⏱️ Time: O(n) Space: O(h)

This optimal approach uses a single DFS traversal, maintaining both the maximum depth seen so far and the sum of nodes at that depth. When we find a deeper level, we reset the sum and update the max depth.

Two-Pass DFS (Brute Force)

⏱️ Time: O(2n) = O(n) Space: O(h)

This approach makes two separate passes through the tree. First pass finds the maximum depth, second pass sums all nodes at that specific depth level.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

TreeNode* createNode(int val) {
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

TreeNode* buildTree(char* input) {
    if (strcmp(input, "") == 0) return NULL;
    
    // Parse input into array
    char* tokens[10000];
    int tokenCount = 0;
    
    char* token = strtok(input, ",");
    while (token != NULL && tokenCount < 10000) {
        tokens[tokenCount++] = token;
        token = strtok(NULL, ",");
    }
    
    if (tokenCount == 0) return NULL;
    
    TreeNode* root = createNode(atoi(tokens[0]));
    TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int i = 1;
    while (front < rear && i < tokenCount) {
        TreeNode* current = queue[front++];
        
        // Left child
        if (i < tokenCount) {
            if (strlen(tokens[i]) > 0 && strcmp(tokens[i], "") != 0) {
                current->left = createNode(atoi(tokens[i]));
                queue[rear++] = current->left;
            }
            i++;
        }
        
        // Right child
        if (i < tokenCount) {
            if (strlen(tokens[i]) > 0 && strcmp(tokens[i], "") != 0) {
                current->right = createNode(atoi(tokens[i]));
                queue[rear++] = current->right;
            }
            i++;
        }
    }
    
    return root;
}

int findMaxDepth(TreeNode* root) {
    if (root == NULL) return 0;
    
    TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int depth = 0;
    while (front < rear) {
        int levelSize = rear - front;
        depth++;
        
        for (int i = 0; i < levelSize; i++) {
            TreeNode* current = queue[front++];
            if (current->left) queue[rear++] = current->left;
            if (current->right) queue[rear++] = current->right;
        }
    }
    
    return depth;
}

int sumDeepestLeaves(TreeNode* root) {
    if (root == NULL) return 0;
    
    int maxDepth = findMaxDepth(root);
    
    // BFS to find nodes at max depth
    TreeNode* queue[10000];
    int depths[10000];
    int front = 0, rear = 0;
    
    queue[rear] = root;
    depths[rear] = 1;
    rear++;
    
    int sum = 0;
    while (front < rear) {
        TreeNode* current = queue[front];
        int currentDepth = depths[front];
        front++;
        
        if (currentDepth == maxDepth) {
            sum += current->val;
        }
        
        if (current->left) {
            queue[rear] = current->left;
            depths[rear] = currentDepth + 1;
            rear++;
        }
        
        if (current->right) {
            queue[rear] = current->right;
            depths[rear] = currentDepth + 1;
            rear++;
        }
    }
    
    return sum;
}

void freeTree(TreeNode* root) {
    if (root == NULL) return;
    freeTree(root->left);
    freeTree(root->right);
    free(root);
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    TreeNode* root = buildTree(input);
    int result = sumDeepestLeaves(root);
    
    printf("%d\n", result);
    
    freeTree(root);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ 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