Find the Level of Tree with Minimum Sum

Find the Level of Tree with Minimum Sum - Problem

Given the root of a binary tree where each node has a value, return the level of the tree that has the minimum sum of values among all the levels.

In case of a tie, return the lowest level. Note that the root of the tree is at level 1 and the level of any other node is its distance from the root + 1.

Input & Output

Example 1 — Basic Case

$ Input: root = [1,7,0,7,-8,null,null]

› Output: 3

💡 Note: Level 1: sum = 1, Level 2: sum = 7+0 = 7, Level 3: sum = 7+(-8) = -1. Level 3 has the minimum sum of -1.

Example 2 — Single Node

$ Input: root = [5]

› Output: 1

💡 Note: Only one level with sum = 5, so return level 1.

Example 3 — Tie Case

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

› Output: 1

💡 Note: Level 1: sum = 1, Level 2: sum = 2+3 = 5, Level 3: sum = 4+5+6+7 = 22. Level 1 has minimum sum.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵

Visualization

Tap to expand

Asked in

a Amazon 25 M Microsoft 18

The key insight is to process the binary tree level by level to calculate the sum at each level, then find the level with minimum sum. Best approach is BFS level-order traversal which naturally processes complete levels. Time: O(n), Space: O(w) where w is maximum tree width.

Common Approaches

✓ DFS with Level Tracking

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

Perform depth-first search while keeping track of the current level. Maintain a map or array to store the sum of values at each level, then find the level with minimum sum.

Level-Order BFS

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

Use breadth-first search with a queue to process all nodes at each level together. Calculate the sum for each complete level and track the minimum sum level.

DFS with Level Tracking — Algorithm Steps

Step 1: DFS traverse the tree with level parameter
Step 2: Accumulate sums for each level in a map
Step 3: Find level with minimum sum

Visualization

Tap to expand

Step-by-Step Walkthrough

DFS Traversal

Visit each node with its level

Sum Calculation

Accumulate values at each level

Find Minimum

Return level with minimum sum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.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* line) {
    if (strlen(line) <= 2) return NULL;
    
    char* ptr = line + 1; // Skip '['
    
    // Parse first value
    if (*ptr == ']') return NULL;
    
    int rootVal = strtol(ptr, &ptr, 10);
    TreeNode* root = createNode(rootVal);
    
    TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear && *ptr) {
        TreeNode* node = queue[front++];
        
        // Skip comma
        if (*ptr == ',') ptr++;
        
        // Left child
        if (*ptr && *ptr != ']') {
            if (strncmp(ptr, "null", 4) == 0) {
                ptr += 4;
            } else {
                int val = strtol(ptr, &ptr, 10);
                node->left = createNode(val);
                queue[rear++] = node->left;
            }
        }
        
        // Skip comma
        if (*ptr == ',') ptr++;
        
        // Right child
        if (*ptr && *ptr != ']') {
            if (strncmp(ptr, "null", 4) == 0) {
                ptr += 4;
            } else {
                int val = strtol(ptr, &ptr, 10);
                node->right = createNode(val);
                queue[rear++] = node->right;
            }
        }
    }
    
    return root;
}

int solution(TreeNode* root) {
    if (!root) return 1;
    
    TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int minSum = root->val;
    int minLevel = 1;
    int currentLevel = 1;
    
    while (front < rear) {
        int levelSize = rear - front;
        int levelSum = 0;
        
        for (int i = 0; i < levelSize; i++) {
            TreeNode* node = queue[front++];
            levelSum += node->val;
            
            if (node->left) {
                queue[rear++] = node->left;
            }
            if (node->right) {
                queue[rear++] = node->right;
            }
        }
        
        if (levelSum < minSum) {
            minSum = levelSum;
            minLevel = currentLevel;
        }
        
        currentLevel++;
    }
    
    return minLevel;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during DFS traversal

✓ Linear Growth

Space Complexity

O(h + d)

O(h) for recursion stack depth, O(d) for storing sums of d levels

✓ Linear Space

28.0K Views

Medium Frequency

~15 min Avg. Time

850 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

DFS with Level Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler