Maximum Width of Binary Tree in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the queue with the root node and its index 0.

DSA Typescript

const queue: Array<[TreeNode | null, number]> = [[[1], 0]];

Drag options to blanks, or click blank then click option'

Aroot

B0

Cundefined

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using null or undefined instead of root.

Starting with an empty queue.

We start the queue with the root node and index 0 to track positions in the tree.

2fill in blank

medium

Complete the code to calculate the width of the current level.

DSA Typescript

const width = lastIndex - firstIndex + [1];

Drag options to blanks, or click blank then click option'

A1

B0

C-1

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 instead of 1, which undercounts width.

Using 2 or -1, which gives incorrect width.

Width is calculated as last index minus first index plus one to count all nodes in between.

3fill in blank

hard

Fix the error in the code to add child nodes to the queue with correct indices.

DSA Typescript

if (node.left) queue.push([node.left, [1]]);

Drag options to blanks, or click blank then click option'

Aindex - 1

Bindex + 1

Cindex * 2 + 1

Dindex * 2

Attempts:

3 left

💡 Hint

Common Mistakes

Using index + 1 which is incorrect for left child.

Using index * 2 + 1 which is for right child.

Left child index is calculated as parent index times 2 to maintain position.

4fill in blank

hard

Fill both blanks to add the right child node to the queue with correct index calculation.

DSA Typescript

if (node.right) queue.push([node.right, [1]]);

Drag options to blanks, or click blank then click option'

Aindex * 2

Bindex + 1

Cindex * 2 + 1

Dindex - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using index * 2 which is for left child.

Using index + 1 which is incorrect for this calculation.

Right child index is parent index times 2 plus 1 to keep correct position.

5fill in blank

hard

Fill all three blanks to complete the function that returns the maximum width of the binary tree.

DSA Typescript

function widthOfBinaryTree(root: TreeNode | null): number {
  if (!root) return 0;
  let maxWidth = 0;
  const queue: Array<[TreeNode, number]> = [[root, 0]];

  while (queue.length > 0) {
    const levelLength = queue.length;
    const firstIndex = queue[0][1];
    const lastIndex = queue[levelLength - 1][1];
    maxWidth = Math.max(maxWidth, lastIndex - firstIndex + [1]);

    for (let i = 0; i < levelLength; i++) {
      const [node, index] = queue.shift()!;
      const normalizedIndex = index - firstIndex;
      if (node.left) queue.push([node.left, normalizedIndex * 2 + [2]]);
      if (node.right) queue.push([node.right, normalizedIndex * 2 + [3]]);
    }
  }

  return maxWidth;
}

Drag options to blanks, or click blank then click option'

A0

B1

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to add 1 in width calculation.

Swapping left and right child index offsets.

Width calculation adds 1; left child index is normalizedIndex * 2 + 0; right child index is normalizedIndex * 2 + 1.

Practice

1. What does the "maximum width" of a binary tree represent?

easy

A. The largest number of nodes present at any single level of the tree

B. The height of the tree from root to the deepest leaf

C. The total number of nodes in the tree

D. The sum of values of all nodes at the widest level

Solution

1. Step 1: Understand the definition of width in a binary tree

   The width is the count of nodes at a particular level in the tree.

2. Step 2: Identify maximum width

   The maximum width is the largest such count among all levels.

3. Final Answer:

   The largest number of nodes present at any single level of the tree -> Option A

4. Quick Check:

   Maximum width = max nodes at any level [OK]

Hint: Width means count of nodes at one level, not height or sum [OK]

Common Mistakes:

• Confusing width with height of the tree
• Thinking width is total nodes in the tree
• Assuming width is sum of node values

2. Which TypeScript data structure is best suited to track nodes level by level when finding maximum width of a binary tree?

easy

A. Queue

B. Stack

C. Set

D. Map

Solution

1. Step 1: Identify traversal method for levels

   Level order traversal visits nodes level by level, which uses a queue.

2. Step 2: Choose data structure for level order

   A queue allows FIFO order, perfect for processing nodes in each level sequentially.

3. Final Answer:

   Queue -> Option A

4. Quick Check:

   Level order traversal uses queue [OK]

Hint: Use queue for level-by-level traversal [OK]

Common Mistakes:

• Using stack which is LIFO, not suitable for level order
• Using set which doesn't maintain order
• Using map which is key-value, not for traversal order

3. What will be the output of the following TypeScript code snippet that calculates maximum width of a binary tree?

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val: number) {
    this.val = val;
    this.left = null;
    this.right = null;
  }
}

const root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);
root.right.right = new TreeNode(5);

function maxWidth(root: TreeNode | null): number {
  if (!root) return 0;
  const queue: Array<TreeNode> = [root];
  let maxWidth = 0;
  while (queue.length > 0) {
    const levelSize = queue.length;
    maxWidth = Math.max(maxWidth, levelSize);
    for (let i = 0; i < levelSize; i++) {
      const node = queue.shift()!;
      if (node.left) queue.push(node.left);
      if (node.right) queue.push(node.right);
    }
  }
  return maxWidth;
}

console.log(maxWidth(root));

medium

A. 3

B. 2

C. 1

D. 4

Solution

1. Step 1: Analyze tree structure and levels

   Level 1: Node 1 (width 1) Level 2: Nodes 2, 3 (width 2) Level 3: Nodes 4, 5 (width 2)

2. Step 2: Check code logic for max width

   Code tracks queue length per level and updates maxWidth. Max width found is 2 at levels 2 and 3.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   Max width = 2 nodes at widest level [OK]

Hint: Count nodes per level, track max count [OK]

Common Mistakes:

• Counting total nodes instead of per level
• Assuming width is height of tree
• Ignoring null children in width calculation

4. The following TypeScript function aims to find the maximum width of a binary tree but has a bug. What is the bug?

function maxWidth(root: TreeNode | null): number {
  if (!root) return 0;
  const queue: Array<TreeNode> = [root];
  let maxWidth = 0;
  while (queue.length > 0) {
    const levelSize = queue.length;
    maxWidth = Math.max(maxWidth, levelSize);
    for (let i = 0; i <= levelSize; i++) {
      const node = queue.shift()!;
      if (node.left) queue.push(node.left);
      if (node.right) queue.push(node.right);
    }
  }
  return maxWidth;
}

medium

A. The maxWidth should be updated after the for loop

B. The queue should be a stack for correct traversal

C. The for loop condition should be i < levelSize, not i <= levelSize

D. The function should return queue.length instead of maxWidth

Solution

1. Step 1: Examine the for loop condition

   The loop runs from i = 0 to i <= levelSize, which means it runs levelSize + 1 times.

2. Step 2: Identify impact of off-by-one error

   Calling queue.shift() one extra time causes undefined or error because queue is empty after levelSize removals.

3. Final Answer:

   The for loop condition should be i < levelSize, not i <= levelSize -> Option C

4. Quick Check:

   Loop runs exactly levelSize times [OK]

Hint: Use i < levelSize for loops over fixed-size levels [OK]

Common Mistakes:

• Using <= instead of < in loops causing extra iteration
• Confusing queue with stack for level order
• Updating maxWidth inside loop incorrectly

5. Given a binary tree where some nodes are missing (null), how can you modify the maximum width calculation to include the 'null' positions between nodes, so the width counts the distance between the leftmost and rightmost non-null nodes at each level? Choose the best approach to solve this problem in TypeScript.

hard

A. Count only non-null nodes per level ignoring positions

B. Calculate width by summing values of nodes at each level

C. Use a stack instead of a queue to track nodes

D. Assign an index to each node as if the tree was a complete binary tree, then calculate width as rightmost index - leftmost index + 1 per level

Solution

1. Step 1: Understand the problem with missing nodes

   Simply counting nodes misses gaps caused by nulls, so width must consider positions.

2. Step 2: Use indexing like a complete binary tree

   Assign indices to nodes: root = 0, left child = 2*index, right child = 2*index + 1. Track min and max indices per level to find width including gaps.

3. Final Answer:

   Assign an index to each node as if the tree was a complete binary tree, then calculate width as rightmost index - leftmost index + 1 per level -> Option D

4. Quick Check:

   Index nodes to include null gaps [OK]

Hint: Use complete tree indexing to count gaps [OK]

Common Mistakes:

• Ignoring null gaps and counting only nodes
• Using stack which breaks level order
• Summing node values instead of counting width