Maximum Width of Binary Tree - Practice Coding Problems

Maximum Width of Binary Tree - Problem

Maximum Width of Binary Tree

Given the root of a binary tree, your task is to find the maximum width among all levels of the tree. Think of this as measuring the "widest spread" of nodes at any horizontal level.

The width of a level is defined as the distance between the leftmost and rightmost non-null nodes at that level, including any null nodes that would exist in between if we were to complete the binary tree structure.

For example, if at level 2 you have nodes at positions 1 and 7, the width would be 7 - 1 + 1 = 7, even if positions 2, 3, 4, 5, and 6 are null.

Input: Root of a binary tree
Output: Maximum width (integer) across all levels

The answer is guaranteed to fit in a 32-bit signed integer.

Input & Output

example_1.py — Simple Tree

$ Input: [1,3,2,5,3,null,9]

› Output: 4

💡 Note: The maximum width is at level 2 with nodes at positions 2,3,6,7. The width is 7-2+1 = 6. Wait, let me recalculate: positions are 2,3 for left subtree and 6,7 for right subtree, so width is 7-2+1 = 6. Actually, looking at the standard example, the output should be 4, which means the width calculation considers the span from leftmost to rightmost node.

example_2.py — Single Node

$ Input: [1]

› Output: 1

💡 Note: Single node tree has width 1 at level 0.

example_3.py — Left-Heavy Tree

$ Input: [1,3,2,5,null,null,9,6,null,7]

› Output: 7

💡 Note: At the deepest level, we have nodes at positions that span a width of 7. The tree is skewed which creates a large width at lower levels.

Constraints

The number of nodes in the tree is in the range [0, 3000]
-100 ≤ Node.val ≤ 100
The answer is guaranteed to fit in a 32-bit signed integer

Visualization

Tap to expand

Understanding the Visualization

Position Assignment

Assign each node a position as if tree were complete: root=0, left_child=2*parent, right_child=2*parent+1

Level Processing

Process each level using BFS, tracking the leftmost and rightmost positions

Width Calculation

For each level, width = rightmost_position - leftmost_position + 1

Maximum Tracking

Keep track of the maximum width encountered across all levels

Key Takeaway

🎯 Key Insight: By treating the binary tree as if it were a complete binary tree and assigning position indices, we can calculate the width of any level using simple arithmetic: rightmost_pos - leftmost_pos + 1

Asked in

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

The optimal approach uses BFS (level-order traversal) with position indexing. Each node gets a position as if the tree were complete: root at 0, left child at 2*parent, right child at 2*parent+1. For each level, we calculate width as rightmost_position - leftmost_position + 1 and track the maximum across all levels. Time: O(n), Space: O(w) where w is maximum width.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Level Tracking (Alternative)	O(n)	O(h + d)	Use DFS to track min/max positions at each level
Level-by-Level BFS with Full Position Tracking	O(n)	O(w)	Store all node positions at each level, then calculate width

DFS with Level Tracking (Alternative) — Algorithm Steps

Use DFS to traverse the tree with depth and position parameters
Maintain a dictionary mapping level to [min_pos, max_pos]
For each node, update the min/max positions for its level
Calculate width for each level and track the maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

DFS Traversal

Visit nodes in DFS order while tracking level and position

Range Updates

Update min/max position for each level as we encounter nodes

Width Calculation

Calculate width for each level: maxPos - minPos + 1

Code -

solution.c — C

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

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

struct LevelRange {
    int level;
    unsigned long long minPos;
    unsigned long long maxPos;
};

struct LevelRange ranges[1000];
int rangeCount = 0;

void dfs(struct TreeNode* node, int level, unsigned long long pos) {
    if (!node) return;
    
    // Find or create range for this level
    int found = -1;
    for (int i = 0; i < rangeCount; i++) {
        if (ranges[i].level == level) {
            found = i;
            break;
        }
    }
    
    if (found == -1) {
        ranges[rangeCount].level = level;
        ranges[rangeCount].minPos = pos;
        ranges[rangeCount].maxPos = pos;
        rangeCount++;
    } else {
        if (pos < ranges[found].minPos) ranges[found].minPos = pos;
        if (pos > ranges[found].maxPos) ranges[found].maxPos = pos;
    }
    
    dfs(node->left, level + 1, 2ULL * pos);
    dfs(node->right, level + 1, 2ULL * pos + 1);
}

int widthOfBinaryTree(struct TreeNode* root) {
    if (!root) return 0;
    
    rangeCount = 0;
    dfs(root, 0, 0);
    
    int maxWidth = 0;
    for (int i = 0; i < rangeCount; i++) {
        int width = ranges[i].maxPos - ranges[i].minPos + 1;
        if (width > maxWidth) {
            maxWidth = width;
        }
    }
    
    return maxWidth;
}

int main() {
    printf("%d\n", widthOfBinaryTree(NULL));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in DFS traversal

✓ Linear Growth

Space Complexity

O(h + d)

O(h) for recursion stack, O(d) for level tracking where d is tree depth

✓ Linear Space

67.2K Views

Medium-High Frequency

~25 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

DFS with Level Tracking (Alternative) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler