Maximum Level Sum of a Binary Tree - Practice Coding Problems

Maximum Level Sum of a Binary Tree - Problem

Maximum Level Sum of a Binary Tree

Imagine you're exploring a multi-story building where each floor represents a level in a binary tree. Your task is to find which floor has the maximum sum of all room numbers on that floor!

Given the root of a binary tree, where the root is at level 1, its children are at level 2, and so on, you need to:

🎯 Calculate the sum of all node values at each level
🔍 Find the level with the maximum sum
📍 Return the smallest level number if there's a tie

For example, if level 2 has sum 15 and level 3 also has sum 15, return 2 since it's the smaller level number.

Input: Root of a binary tree
Output: Integer representing the level with maximum sum

Input & Output

example_1.py — Basic Tree

$ Input: [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 level with maximum sum is level 2 with sum = 7.

example_2.py — Negative Root

$ Input: [-100,-200,-300]

› Output: 3

💡 Note: Level 1 sum = -100. Level 2 sum = -200 + (-300) = -500. The level with maximum sum is level 1 with sum = -100.

example_3.py — Single Node

$ Input: [1]

› Output: 1

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

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵
Level numbering starts from 1 (root level)

Visualization

Tap to expand

Understanding the Visualization

Start at Ground Floor

Begin BFS at the root (ground floor lobby)

Process Each Floor

For each floor, sum all room revenues (node values)

Track Maximum

Keep track of which floor has the highest total revenue

Move to Next Floor

Process children nodes (rooms on the next floor up)

Return Best Floor

Return the floor number with maximum revenue

Key Takeaway

🎯 Key Insight: BFS naturally processes tree nodes level by level, making it perfect for calculating level sums in a single traversal. This gives us O(n) time complexity - optimal for this problem!

Asked in

A Amazon 15 ⊞ Microsoft 12 G Google 8 f Meta 6

The optimal solution uses BFS (Breadth-First Search) to traverse the tree level by level in O(n) time. For each level, we calculate the sum of all nodes and track the level with the maximum sum. BFS naturally processes nodes level by level using a queue, making it perfect for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ BFS Level-by-Level (Optimal)	O(n)	O(w)	Use BFS to process nodes level by level in a single traversal

BFS Level-by-Level (Optimal) — Algorithm Steps

Initialize queue with root node and level counter
For each level, process all nodes currently in the queue
Calculate sum of current level and compare with maximum
Add children of current level nodes to queue for next iteration
Return the level with maximum sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with root in queue, level 1

Process Level 1

Sum: 1, add children to queue

Process Level 2

Sum: 7+0=7, add children to queue

Process Level 3

Sum: 7+(-8)=-1, no more children

Result

Maximum sum 7 found at level 2

Code -

solution.c — C

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

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

// Simple queue implementation for BFS
struct QueueNode {
    struct TreeNode* treeNode;
    struct QueueNode* next;
};

struct Queue {
    struct QueueNode* front;
    struct QueueNode* rear;
    int size;
};

struct Queue* createQueue() {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->front = q->rear = NULL;
    q->size = 0;
    return q;
}

void enqueue(struct Queue* q, struct TreeNode* node) {
    struct QueueNode* temp = (struct QueueNode*)malloc(sizeof(struct QueueNode));
    temp->treeNode = node;
    temp->next = NULL;
    
    if (q->rear == NULL) {
        q->front = q->rear = temp;
    } else {
        q->rear->next = temp;
        q->rear = temp;
    }
    q->size++;
}

struct TreeNode* dequeue(struct Queue* q) {
    if (q->front == NULL) return NULL;
    
    struct QueueNode* temp = q->front;
    struct TreeNode* node = temp->treeNode;
    q->front = q->front->next;
    
    if (q->front == NULL) q->rear = NULL;
    
    free(temp);
    q->size--;
    return node;
}

int maxLevelSum(struct TreeNode* root) {
    if (!root) return 1;
    
    struct Queue* queue = createQueue();
    enqueue(queue, root);
    int maxSum = INT_MIN;
    int maxLevel = 1;
    int currentLevel = 1;
    
    while (queue->size > 0) {
        int levelSize = queue->size;
        int levelSum = 0;
        
        // Process all nodes at current level
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = dequeue(queue);
            levelSum += node->val;
            
            // Add children for next level
            if (node->left) enqueue(queue, node->left);
            if (node->right) enqueue(queue, node->right);
        }
        
        // Update maximum if current level sum is greater
        if (levelSum > maxSum) {
            maxSum = levelSum;
            maxLevel = currentLevel;
        }
        
        currentLevel++;
    }
    
    free(queue);
    return maxLevel;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once during the BFS traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes where w is the maximum width of the tree

✓ Linear Space

24.7K Views

Medium Frequency

~15 min Avg. Time

892 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

BFS Level-by-Level (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler