Maximum Width of Binary Tree

Maximum Width of Binary Tree - Problem

Given the root of a binary tree, return the maximum width of the given tree.

The maximum width of a tree is the maximum width among all levels. The width of one level is defined as the length between the end-nodes (the leftmost and rightmost non-null nodes), where the null nodes between the end-nodes that would be present in a complete binary tree extending down to that level are also counted into the length calculation.

It is guaranteed that the answer will be in the range of a 32-bit signed integer.

Input & Output

Example 1 — Standard Tree

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

› Output: 4

💡 Note: At level 3, we have nodes 5, 3, and 9. In a complete binary tree representation, positions would be 0, 1, and 3, giving width = 3 - 0 + 1 = 4

Example 2 — Skewed Tree

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

› Output: 8

💡 Note: At the deepest level, nodes 6 and 7 are at positions 4 and 11 in the complete tree representation, giving width = 11 - 4 + 1 = 8

Example 3 — Single Node

$ Input: root = [1]

› Output: 1

💡 Note: Tree has only root node, so maximum width is 1

Constraints

The number of nodes in the tree is in the range [1, 3000]
-100 ≤ Node.val ≤ 100

Visualization

Tap to expand

Asked in

F Facebook 25 G Google 18 A Amazon 12 M Microsoft 8

The key insight is to use BFS with position tracking where each node gets a position index based on binary tree properties (left child = 2*parent, right child = 2*parent+1). The optimal approach uses position normalization to prevent integer overflow. Time: O(n), Space: O(w) where w is maximum width.

Common Approaches

✓ BFS with Position Normalization

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

Traverse level by level using BFS. For each level, normalize positions by subtracting the leftmost position to prevent integer overflow. Calculate width using first and last positions.

Level Order with Full Position Tracking

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

For each level, track all positions where nodes could exist in a complete binary tree. Calculate width by finding the difference between leftmost and rightmost actual nodes.

BFS with Position Normalization — Algorithm Steps

Use BFS to traverse tree level by level
For each node, assign position based on parent position
Normalize positions at each level to prevent overflow
Calculate width as last_pos - first_pos + 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Level Processing

Process one level at a time

Position Normalization

Subtract leftmost position to normalize

Width Calculation

Width = normalized_last - normalized_first + 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 NodePos {
    struct TreeNode* node;
    long long pos;
};

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

void parseArray(const char* str, int* arr, int* size, int* hasNull, int maxSize) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    int idx = 0;
    while (*p && *p != ']' && idx < maxSize) {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (strncmp(p, "null", 4) == 0) {
            hasNull[idx] = 1;
            arr[idx] = 0;
            p += 4;
        } else {
            hasNull[idx] = 0;
            arr[idx] = (int)strtol(p, (char**)&p, 10);
        }
        idx++;
    }
    *size = idx;
}

struct TreeNode* buildTree(int* arr, int* hasNull, int size) {
    if (size == 0 || hasNull[0]) {
        return NULL;
    }
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && !hasNull[i]) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && !hasNull[i]) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

int solution(struct TreeNode* root) {
    if (!root) return 0;
    
    int max_width = 0;
    struct NodePos queue[10000];
    int front = 0, rear = 0;
    
    queue[rear++] = (struct NodePos){root, 0};
    
    while (front < rear) {
        int level_size = rear - front;
        long long leftmost_pos = queue[front].pos;
        long long first_pos = 0, last_pos = 0;
        
        for (int i = 0; i < level_size; i++) {
            struct NodePos current = queue[front++];
            long long normalized_pos = current.pos - leftmost_pos;
            
            if (i == 0) {
                first_pos = normalized_pos;
            }
            if (i == level_size - 1) {
                last_pos = normalized_pos;
            }
            
            if (current.node->left) {
                queue[rear++] = (struct NodePos){current.node->left, 2 * current.pos};
            }
            if (current.node->right) {
                queue[rear++] = (struct NodePos){current.node->right, 2 * current.pos + 1};
            }
        }
        
        int width = (int)(last_pos - first_pos + 1);
        if (width > max_width) {
            max_width = width;
        }
    }
    
    return max_width;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int arr[10000];
    int hasNull[10000];
    int size;
    parseArray(input, arr, &size, hasNull, 10000);
    
    struct TreeNode* root = buildTree(arr, hasNull, size);
    
    int result = solution(root);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in BFS traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes where w is maximum width of any level

✓ Linear Space

87.0K Views

Medium Frequency

~25 min Avg. Time

2.2K 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 with Position Normalization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler