Zigzag Level Order Traversal in DSA C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is Zigzag Level Order Traversal in a binary tree?

It is a way to traverse a binary tree level by level, but alternating the direction of traversal at each level. For example, left to right on one level, then right to left on the next.

beginner

Which data structure is commonly used to implement Zigzag Level Order Traversal?

A queue is used to process nodes level by level, and sometimes a stack or reversing the order is used to alternate the direction.

intermediate

How do you decide the direction of traversal at each level in Zigzag Level Order Traversal?

You use a boolean flag or a counter to track the current level. If the level is even, traverse left to right; if odd, traverse right to left.

beginner

What is the time complexity of Zigzag Level Order Traversal?

The time complexity is O(n), where n is the number of nodes in the tree, because each node is visited exactly once.

intermediate

Why might you use Zigzag Level Order Traversal instead of normal level order traversal?

It can be useful to visualize or process tree data in a way that captures alternating directions, which might represent certain patterns or requirements in problems.

In Zigzag Level Order Traversal, what data structure is primarily used to hold nodes of the current level?

A Stack

B Linked List

C Queue

D Hash Map

A queue is used to process nodes level by level in order.

How do you alternate the direction of traversal in Zigzag Level Order Traversal?

A Always traverse left to right

B Reverse the order of nodes at every alternate level

C Use a stack only

D Traverse randomly

You reverse the order of nodes at every alternate level to achieve zigzag pattern.

What is the output of Zigzag Level Order Traversal for a tree with only one node?

A [[root, root]]

B []

C [root]

D [[root]]

The traversal returns a list of levels, so a single node is [[root]].

What is the time complexity of Zigzag Level Order Traversal?

A O(n)

B O(n^2)

C O(log n)

D O(1)

Each node is visited once, so time complexity is O(n).

Which of these is NOT a typical step in Zigzag Level Order Traversal?

A Sorting nodes by value at each level

B Reversing node order on alternate levels

C Using a flag to track direction

D Using a queue to track nodes

Sorting nodes by value is not part of zigzag traversal.

Explain how you would implement Zigzag Level Order Traversal on a binary tree.

Think about how to process nodes level by level and flip direction each time.

Describe the difference between normal level order traversal and zigzag level order traversal.

Focus on the direction of traversal at each level.

Practice

1. What does Zigzag Level Order Traversal of a binary tree mean?

easy

A. Traverse nodes level by level, alternating left to right and right to left

B. Traverse nodes only from left to right at each level

C. Traverse nodes only from right to left at each level

D. Traverse nodes randomly without any order

Solution

1. Step 1: Understand level order traversal

   Level order traversal visits nodes level by level from left to right.

2. Step 2: Add zigzag pattern

   Zigzag means alternate direction each level: first left to right, then right to left, and so on.

3. Final Answer:

   Traverse nodes level by level, alternating left to right and right to left -> Option A

4. Quick Check:

   Zigzag = alternate directions [OK]

Hint: Remember zigzag means alternate directions each level [OK]

Common Mistakes:

• Thinking traversal is always left to right
• Confusing zigzag with preorder or inorder traversal
• Ignoring the alternating direction pattern

2. Which of the following C++ code snippets correctly initializes a queue for level order traversal?

easy

A. std::list q; q.push_front(root);

B. std::stack q; q.push(root);

C. std::vector q; q.push_back(root);

D. std::queue q; q.push(root);

Solution

1. Step 1: Identify correct data structure for level order

   Level order traversal uses a queue to process nodes FIFO (first in, first out).

2. Step 2: Check code snippets

   std::queue q; q.push(root); uses std::queue and pushes root correctly. Others use stack, vector, or list incorrectly for this purpose.

3. Final Answer:

   std::queue q; q.push(root); -> Option D

4. Quick Check:

   Queue for level order = std::queue q; q.push(root); [OK]

Hint: Use queue for level order traversal, not stack or vector [OK]

Common Mistakes:

• Using stack instead of queue
• Using vector push_back but no FIFO behavior
• Using list with push_front which reverses order

3. What is the output of the zigzag level order traversal for this tree?

    1
   / \
  2   3
 / \   \
4   5   6

medium

A. [[1], [3, 2], [4, 5, 6]]

B. [[1], [2, 3], [6, 5, 4]]

C. [[1], [3, 2], [6, 5, 4]]

D. [[1], [2, 3], [4, 5, 6]]

Solution

1. Step 1: Traverse level 0 left to right

   Level 0 has node 1, so output is [1].

2. Step 2: Traverse level 1 right to left

   Level 1 nodes are 2 and 3. Zigzag means reverse order here: [3, 2].

3. Step 3: Traverse level 2 left to right

   Level 2 nodes are 4, 5, 6 from left to right: [4, 5, 6].

4. Final Answer:

   [[1], [3, 2], [4, 5, 6]] -> Option A

5. Quick Check:

   Zigzag levels alternate direction [OK]

Hint: Alternate direction each level starting left to right [OK]

Common Mistakes:

• Not reversing order on alternate levels
• Mixing node order at last level
• Confusing left and right child order

4. Identify the bug in this C++ snippet for zigzag traversal:

std::vector zigzagLevelOrder(TreeNode* root) {
  std::vector result;
  if (!root) return result;
  std::queue q;
  q.push(root);
  bool leftToRight = true;
  while (!q.empty()) {
    int size = q.size();
    std::vector<int> level(size);
    for (int i = 0; i < size; ++i) {
      TreeNode* node = q.front(); q.pop();
      int index = leftToRight ? i : size - i - 1;
      level[index] = node->val;
      if (node->left) q.push(node->left);
      if (node->right) q.push(node->right);
    }
    result.push_back(level);
  }
  return result;
}

medium

A. Using vector<int> level(size) instead of vector<int> level

B. Incorrect queue initialization

C. Missing toggle of leftToRight after each level

D. Not checking if root is null

Solution

1. Step 1: Analyze loop for toggling direction

   The variable leftToRight controls direction but is never changed inside the loop.

2. Step 2: Identify missing toggle

   Without toggling leftToRight = !leftToRight; after processing each level, zigzag pattern won't alternate.

3. Final Answer:

   Missing toggle of leftToRight after each level -> Option C

4. Quick Check:

   Toggle direction each level [OK]

Hint: Toggle direction flag after each level to alternate traversal [OK]

Common Mistakes:

• Forgetting to flip leftToRight boolean
• Incorrect indexing in level vector
• Not pushing child nodes properly

5. Given a binary tree, how would you modify the zigzag level order traversal to return a flat vector of node values instead of a vector of vectors? For example, for tree:

    1
   / \
  2   3
 /     \
4       5

The output should be: [1, 3, 2, 4, 5]

hard

A. Use a stack instead of queue to store nodes for zigzag traversal

B. Perform normal zigzag traversal, then flatten the result vectors into one vector

C. Traverse all nodes left to right ignoring zigzag pattern

D. Return only the last level nodes in zigzag order

Solution

1. Step 1: Perform standard zigzag traversal

   Use queue and toggle direction each level to get vector of vectors with zigzag order.

2. Step 2: Flatten the vector of vectors

   Combine all inner vectors into a single vector preserving order to get flat list.

3. Final Answer:

   Perform normal zigzag traversal, then flatten the result vectors into one vector -> Option B

4. Quick Check:

   Flatten zigzag levels to one vector [OK]

Hint: Flatten after zigzag traversal to get single list [OK]

Common Mistakes:

• Trying to zigzag directly into flat vector without levels
• Using stack incorrectly for zigzag
• Ignoring zigzag pattern and traversing left to right only