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

Recall & Review

beginner

What is Zigzag Level Order Traversal in a binary tree?

It is a way to visit nodes 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.

intermediate

Why do we use two stacks or a deque in Zigzag Level Order Traversal?

To keep track of nodes in the current level and the next level while controlling the order of traversal direction (left to right or right to left).

beginner

What data structure is commonly used to store the result of Zigzag Level Order Traversal?

A list of lists (or array of arrays), where each inner list contains the node values of one level in the zigzag order.

beginner

How does the traversal direction change after each level in Zigzag Level Order Traversal?

The direction toggles between left to right and right to left after completing each level.

intermediate

What is the time complexity of Zigzag Level Order Traversal?

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

In Zigzag Level Order Traversal, what is the order of nodes at level 2 if level 1 is traversed left to right?

A Left to right

B Right to left

C Random order

D Same as level 1

The traversal direction alternates each level, so if level 1 is left to right, level 2 is right to left.

Which data structure is NOT typically used in Zigzag Level Order Traversal?

A HashMap

B Queue

C Deque

D Stack

HashMap is not used for traversal order; stacks, queues, or deques are used to manage node order.

What is the main difference between Zigzag Level Order Traversal and normal Level Order Traversal?

A Zigzag visits nodes randomly

B Zigzag only visits leaf nodes

C Zigzag alternates traversal direction each level

D Zigzag uses recursion only

Zigzag traversal alternates direction at each level, unlike normal level order which is always left to right.

What is the space complexity of Zigzag Level Order Traversal in the worst case?

A O(n^2)

B O(log n)

C O(1)

D O(n)

Space complexity is O(n) because we store nodes of one level at a time, which can be up to n/2 nodes.

Which of these is a correct approach to implement Zigzag Level Order Traversal?

A Use two stacks to alternate the order of nodes

B Use a hash set to track visited nodes

C Use recursion without any data structure

D Use a single queue and reverse the list after each level

Using two stacks is a common approach to alternate traversal order efficiently.

Explain how Zigzag Level Order Traversal works step-by-step on a binary tree.

Think about how you would walk through the tree like a zigzag path.

Describe the data structures and algorithmic steps needed to implement Zigzag Level Order Traversal.

Focus on how to keep track of nodes and direction.

Practice

1. What is the main difference between a normal level order traversal and a zigzag level order traversal of a binary tree?

easy

A. Zigzag traversal alternates the direction of node visits at each level.

B. Zigzag traversal visits nodes only on odd levels.

C. Zigzag traversal visits nodes in reverse order at all levels.

D. Zigzag traversal visits nodes randomly without any order.

Solution

1. Step 1: Understand normal level order traversal

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

2. Step 2: Understand zigzag traversal difference

   Zigzag traversal changes direction at each level, alternating between left-to-right and right-to-left.

3. Final Answer:

   Zigzag traversal alternates the direction of node visits at each level. -> Option A

4. Quick Check:

   Zigzag = alternate direction [OK]

Hint: Remember zigzag flips direction every level [OK]

Common Mistakes:

• Thinking zigzag visits only odd levels
• Assuming zigzag always goes right to left
• Confusing zigzag with random order

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

easy

A. Queue<TreeNode> queue = new ArrayList<>();

B. Queue<TreeNode> queue = new HashSet<>();

C. Queue<TreeNode> queue = new Stack<>();

D. Queue<TreeNode> queue = new LinkedList<>();

Solution

1. Step 1: Identify correct queue implementation

   Java's Queue interface is commonly implemented by LinkedList for FIFO behavior.

2. Step 2: Check other options

   ArrayList is a list, not a queue; Stack is LIFO, not queue; HashSet is a set, no order.

3. Final Answer:

   Queue<TreeNode> queue = new LinkedList<>(); -> Option D

4. Quick Check:

   Queue = LinkedList [OK]

Hint: Use LinkedList for queue in Java [OK]

Common Mistakes:

• Using ArrayList instead of Queue
• Using Stack which is LIFO, not FIFO
• Using HashSet which has no order

3. Given the binary tree below, what is the zigzag level order traversal output?

    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 nodes: [1]

2. Step 2: Traverse level 1 right to left

   Level 1 nodes: [2, 3] reversed to [3, 2]

3. Step 3: Traverse level 2 left to right

   Level 2 nodes: [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 nodes on odd levels
• Reversing nodes on even levels incorrectly
• Mixing node order at last level

4. Consider the following Java code snippet for zigzag traversal. What is the error?

Queue<TreeNode> queue = new LinkedList<>();
boolean leftToRight = true;
while (!queue.isEmpty()) {
    int size = queue.size();
    List<Integer> level = new ArrayList<>();
    for (int i = 0; i < size; i++) {
        TreeNode node = queue.poll();
        if (leftToRight) level.add(node.val);
        else level.add(0, node.val);
        if (node.left != null) queue.add(node.left);
        if (node.right != null) queue.add(node.right);
    }
    leftToRight = !leftToRight;
}

medium

A. The boolean flag leftToRight should not be toggled.

B. The queue should be a Stack for zigzag traversal.

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

D. The level list should be a LinkedList instead of ArrayList.

Solution

1. Step 1: Analyze for loop condition

   The loop runs from i = 0 to i <= size, which means it runs size+1 times, causing poll() to return null once.

2. Step 2: Correct loop condition

   The loop should run exactly size times, so condition must be i < size.

3. Final Answer:

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

4. Quick Check:

   Loop runs size times [OK]

Hint: Use i < size for loops over queue size [OK]

Common Mistakes:

• Using i <= size causing extra iteration
• Using Stack instead of Queue
• Not toggling direction flag

5. You want to implement zigzag level order traversal but optimize space by using a single deque (double-ended queue). Which approach correctly uses the deque to achieve zigzag traversal?

hard

A. Use deque to add nodes at front for left-to-right levels and remove from end; add nodes at end for right-to-left levels and remove from front.

B. Use deque to add nodes at the end for left-to-right levels and remove from front; add nodes at front for right-to-left levels and remove from end.

C. Use deque to add nodes only at end and remove from front for all levels.

D. Use deque to add nodes only at front and remove from end for all levels.

Solution

1. Step 1: Understand deque usage for zigzag

   For left-to-right levels, add children at the end and remove nodes from front to process in order.

2. Step 2: Reverse direction for right-to-left levels

   For right-to-left levels, add children at front and remove nodes from end to process in reverse order.

3. Final Answer:

   Use deque to add nodes at the end for left-to-right levels and remove from front; add nodes at front for right-to-left levels and remove from end. -> Option B

4. Quick Check:

   Deque add/remove ends alternate by level [OK]

Hint: Alternate deque ends for add/remove by level [OK]

Common Mistakes:

• Adding/removing from same end always
• Not reversing add/remove ends per level
• Using only queue or stack instead of deque