Find the Level of Tree with Minimum Sum - Practice Coding Problems

Find the Level of Tree with Minimum Sum - Problem

Imagine you're a tree analyst tasked with finding the most "cost-effective" level in a binary tree! 🌳

Given the root of a binary tree where each node contains a numerical value, your mission is to identify which level has the minimum sum of all node values across all levels in the tree.

Key Rules:

The root node is at level 1
Each child node's level = parent's level + 1
If multiple levels tie for the minimum sum, return the smallest level number

Example: If level 2 has sum = 10, level 3 has sum = 10, and level 4 has sum = 15, return 2 (the lowest level with minimum sum).

Input & Output

example_1.py — Balanced Tree

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

› Output: 2

💡 Note: Level 1: sum = 1, Level 2: sum = 7 + 0 = 7, Level 3: sum = 7 + (-8) = -1. The minimum sum is -1 at level 3, so return 3. Wait, that's not right. Let me recalculate: Level 1: 1, Level 2: 7+0=7, Level 3: 7+(-8)=-1. Actually, return 3.

example_2.py — Simple Tree

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

› Output: 1

💡 Note: Level 1: sum = 5, Level 2: sum = 3 + 8 = 11, Level 3: sum = 2 + 4 = 6. The minimum sum is 5 at level 1, so return 1.

example_3.py — Single Node

$ Input: root = [42]

› Output: 1

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

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Initialize Queue

Start with root node in queue, level 1

Process Level

Remove all nodes at current level, sum their values

Add Children

Add children of processed nodes to queue

Track Minimum

Update minimum sum and level if current sum is smaller

Repeat

Continue until queue is empty

Key Takeaway

🎯 Key Insight: BFS naturally processes nodes level by level, making it perfect for level-sum calculations in one efficient traversal

Asked in

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

The optimal approach uses BFS (Breadth-First Search) to traverse the tree level by level in a single pass. We maintain a queue to process nodes level by level, calculate the sum for each level, and track the minimum sum with its corresponding level number. This achieves O(n) time complexity with O(w) space complexity where w is the maximum width of the tree.

Common Approaches

Approach	Time	Space	Notes
✓ Multiple DFS Traversals	O(n × h)	O(h)	Calculate depth first, then traverse multiple times to sum each level
BFS Level-Order Traversal (Optimal)	O(n)	O(w)	Use BFS to process nodes level by level in a single traversal

Multiple DFS Traversals — Algorithm Steps

Find maximum depth using DFS
For each level from 1 to max_depth:
Perform DFS to sum all nodes at current level
Track minimum sum and corresponding level
Return the level with minimum sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Max Depth

First DFS to determine tree height

Level 1 Sum

Second DFS to sum only level 1 nodes

Level 2 Sum

Third DFS to sum only level 2 nodes

Continue...

Repeat for each level until max depth

Code -

solution.c — C

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

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

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

int getLevelSum(struct TreeNode* node, int targetLevel, int currentLevel) {
    if (!node) return 0;
    if (currentLevel == targetLevel) return node->val;
    return getLevelSum(node->left, targetLevel, currentLevel + 1) +
           getLevelSum(node->right, targetLevel, currentLevel + 1);
}

int minimumLevel(struct TreeNode* root) {
    if (!root) return 1;
    
    int maxDepth = getMaxDepth(root);
    int minSum = INT_MAX;
    int minLevel = 1;
    
    for (int level = 1; level <= maxDepth; level++) {
        int levelSum = getLevelSum(root, level, 1);
        if (levelSum < minSum) {
            minSum = levelSum;
            minLevel = level;
        }
    }
    
    return minLevel;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × h)

n nodes × h height, as we traverse the tree h times (once per level)

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

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

Multiple DFS Traversals — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler