Maximum Width of Binary Tree

Problem statement

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 are also counted into the length calculation.

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

Example 1:

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

Example 2:

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

Example 3:

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

Constraints:

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

My solution

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var widthOfBinaryTree = function(root) {
    const stack = [{
        node: root,
        index : 1
    }]
    
    let maxWidth = 1;
    
    while (stack.length > 0) {
        maxWidth = Math.max(
            maxWidth, 
            (stack[stack.length - 1].index - stack[0].index) + 1
        )
        
        const stackLen = stack.length - 1
        for (let i = stackLen; i >= 0; i--) {
            const {node, index} = stack.shift() || {};
            
            if (node?.left) {
                stack.push({
                    node: node.left,
                    index: index * 2
                })
            }
            
            if (node?.right) {
                stack.push({
                    node: node.right,
                    index: (index * 2) + 1
                })
            }
            
        }
        
        if (stack.length === 1) {
            stack[0].index = 1;
        }
        
        // console.log(stack)
    }
    
    return maxWidth;
};