662. Maximum Width of Binary Tree

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 in the range of a 32-bit signed integer.
 

Example 1:

Input: root = [1,3,2,5,3,null,9]
Output: 4
Explanation: The maximum width exists in the third level with length 4 (5,3,null,9).

Example 2:

Input: root = [1,3,2,5,null,null,9,6,null,7]
Output: 7
Explanation: The maximum width exists in the fourth level with length 7 (6,null,null,null,null,null,7).

Example 3:

Input: root = [1,3,2,5]
Output: 2
Explanation: The maximum width exists in the second level with length 2 (3,2).

Constraints:

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

From: LeetCode
Link: 662. Maximum Width of Binary Tree

---

Solution:

Ideas:

• Each node gets a position index similar to a complete binary tree:
  • Root: index = 0
  • Left child: 2 * index
  • Right child: 2 * index + 1
• For each level, track the first and last indices.
• The width of the level = last - first + 1
• Use a static array to simulate a queue since constraints are within bounds.

Code:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
// Queue node containing TreeNode and its index in a complete binary tree
typedef struct {
    
    
    struct TreeNode *node;
    unsigned long long index; // use unsigned long long to avoid overflow
} QueueNode;

#define MAX_SIZE 3000

int widthOfBinaryTree(struct TreeNode* root) {
    
    
    if (!root) return 0;

    QueueNode queue[MAX_SIZE];
    int front = 0, rear = 0;
    queue[rear++] = (QueueNode){
    
    root, 0};

    int maxWidth = 0;

    while (front < rear) {
    
    
        int levelSize = rear - front;
        unsigned long long left = queue[front].index;
        unsigned long long right = left;

        for (int i = 0; i < levelSize; i++) {
    
    
            QueueNode current = queue[front++];
            struct TreeNode *node = current.node;
            unsigned long long idx = current.index;

            right = idx;

            if (node->left)
                queue[rear++] = (QueueNode){
    
    node->left, 2 * idx};
            if (node->right)
                queue[rear++] = (QueueNode){
    
    node->right, 2 * idx + 1};
        }

        int width = (int)(right - left + 1);
        if (width > maxWidth)
            maxWidth = width;
    }

    return maxWidth;
}