Zigzag Level Order Traversal in DSA Go - Execution Trace

Concept Flow - Zigzag Level Order Traversal

Start at root node

↓

Initialize queue with root

↓

While queue not empty

↓

Process current level nodes

↓

Collect node values in order

↓

If level is even: left to right

↓

Reverse order for odd levels

↓

Add children to queue

↓

Move to next level

↓

Repeat until queue empty

↓

Return zigzag order list

Traverse the tree level by level, alternating the order of node values between left-to-right and right-to-left at each level.

Execution Sample

DSA Go

func zigzagLevelOrder(root *TreeNode) [][]int {
 if root == nil { return [][]int{} }
 queue := []*TreeNode{root}
 result := [][]int{}
 level := 0
 for len(queue) > 0 {
  levelSize := len(queue)
  levelNodes := make([]int, levelSize)
  for i := 0; i < levelSize; i++ {
   node := queue[0]
   queue = queue[1:]
   if level%2 == 0 {
    levelNodes[i] = node.Val
   } else {
    levelNodes[levelSize-1-i] = node.Val
   }
   if node.Left != nil {
    queue = append(queue, node.Left)
   }
   if node.Right != nil {
    queue = append(queue, node.Right)
   }
  }
  result = append(result, levelNodes)
  level++
 }
 return result
}

This code traverses a binary tree level by level, collecting node values in zigzag order.

Execution Table

Step	Operation	Nodes in Queue	Level	Order	Values Collected	Queue After Adding Children	Visual State
1	Start with root node	[3]	0	Left to Right	[3]	[9, 20]	Level 0: 3
2	Process level 1 nodes	[9, 20]	1	Right to Left	[20, 9]	[15, 7]	Level 1: 20 -> 9
3	Process level 2 nodes	[15, 7]	2	Left to Right	[15, 7]	[]	Level 2: 15 -> 7
4	Queue empty, traversal ends	[]	-	-	-	-	Traversal complete

💡 Queue is empty, all levels processed

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
queue	[3]	[9, 20]	[15, 7]	[]	[]
level	0	1	2	3	3
result	[]	[[3]]	[[3],[20,9]]	[[3],[20,9],[15,7]]	[[3],[20,9],[15,7]]

Key Moments - 3 Insights

Why do we reverse the order of values at odd levels?

At odd levels, we collect node values right to left to create the zigzag pattern. See execution_table row 2 where level 1 order is 'Right to Left' and values are reversed.

How do we know when to stop the traversal?

We stop when the queue is empty, meaning no more nodes to process. This is shown in execution_table row 4 where the queue is empty and traversal ends.

Why do we add children to the queue after processing current level?

Adding children after processing ensures we process nodes level by level. The queue after adding children in each step shows the next level nodes to process.

Visual Quiz - 3 Questions

Look at the execution_table, what is the queue after processing level 0?

A [9, 20]

B [15, 7]

C []

D [3]

💡 Hint

Check the 'Queue After Adding Children' column in row 1 of execution_table.

At which level do we collect values in right to left order?

A Level 0

B Level 1

C Level 2

D Traversal end

💡 Hint

Look at the 'Order' column in execution_table rows.

If the root had no children, what would be the final result?

A [[3]]

B []

C [[3], []]

D [[]]

💡 Hint

Refer to variable_tracker 'result' after step 1 and the queue state.

Concept Snapshot

Zigzag Level Order Traversal:
- Traverse tree level by level using a queue.
- Alternate order of node values each level (left-right, then right-left).
- Collect values per level, reverse on odd levels.
- Add children to queue after processing current level.
- Stop when queue is empty.
- Return list of levels with zigzag order.

Full Transcript

Zigzag Level Order Traversal visits nodes level by level in a binary tree. We start at the root and use a queue to keep track of nodes at each level. For each level, we collect node values. On even levels, we collect left to right. On odd levels, we reverse the order to right to left. After processing a level, we add all children of nodes in that level to the queue for the next level. We repeat until the queue is empty, meaning all nodes are processed. The result is a list of lists, each inner list representing a level's node values in zigzag order.

Practice

1. What does the Zigzag Level Order Traversal of a binary tree do differently compared to a normal level order traversal?

easy

A. It alternates the direction of traversal at each level, switching between left-to-right and right-to-left.

B. It only traverses the left subtree of the tree.

C. It visits nodes in a random order at each level.

D. It traverses nodes only in right-to-left order for all levels.

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: Identify zigzag difference

   Zigzag traversal changes direction every level: first left-to-right, then right-to-left, and so on.

3. Final Answer:

   It alternates the direction of traversal at each level, switching between left-to-right and right-to-left. -> Option A

4. Quick Check:

   Zigzag = alternate directions [OK]

Hint: Remember zigzag means direction flips each level [OK]

Common Mistakes:

• Thinking traversal is always left-to-right
• Confusing zigzag with random order
• Ignoring direction change at each level

2. Which of the following Go code snippets correctly initializes a queue for level order traversal in Zigzag Level Order Traversal?

easy

A. queue := make([]int, 0)

B. queue := []int{root}

C. queue := map[int]*TreeNode{}

D. queue := []*TreeNode{root}

Solution

1. Step 1: Identify the queue type needed

   Queue should hold pointers to TreeNode structs, so []*TreeNode is correct.

2. Step 2: Check each option's correctness

   queue := []*TreeNode{root} uses []*TreeNode with root node, correct for traversal. Options A and B use int slices, wrong type. queue := map[int]*TreeNode{} uses map, not queue.

3. Final Answer:

   queue := []*TreeNode{root} -> Option D

4. Quick Check:

   Queue holds TreeNode pointers = queue := []*TreeNode{root} [OK]

Hint: Queue must hold TreeNode pointers, not ints or maps [OK]

Common Mistakes:

• Using int slices instead of TreeNode pointers
• Using map instead of slice for queue
• Not initializing queue with root node

3. Given the binary tree:

    1
   / \
  2   3
 / \   \
4   5   6

What is the output of Zigzag Level Order Traversal?

medium

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

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

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

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

Solution

1. Step 1: Traverse level 0 and 1 with direction

   Level 0: left-to-right -> [1]. Level 1: right-to-left -> [3, 2].

2. Step 2: Traverse level 2 left-to-right

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

3. Final Answer:

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

4. Quick Check:

   Zigzag levels alternate directions = [[1], [3, 2], [4, 5, 6]] [OK]

Hint: Alternate direction each level, left-to-right then right-to-left [OK]

Common Mistakes:

• Not reversing nodes on odd levels
• Reversing nodes on even levels incorrectly
• Mixing node order at last level

4. Consider this Go code snippet for Zigzag Level Order Traversal:

for len(queue) > 0 {
    levelSize := len(queue)
    var level []int
    for i := 0; i < levelSize; i++ {
        node := queue[0]
        queue = queue[1:]
        level = append(level, node.Val)
        if node.Left != nil {
            queue = append(queue, node.Left)
        }
        if node.Right != nil {
            queue = append(queue, node.Right)
        }
    }
    if leftToRight {
        result = append(result, level)
    } else {
        reverse(level)
        result = append(result, level)
    }
    leftToRight = !leftToRight
}

What is the main bug in this code?

medium

A. The reverse function is called but not defined or implemented.

B. The queue is not updated correctly after popping the first element.

C. The variable leftToRight is never initialized before use.

D. The level slice is appended before processing child nodes.

Solution

1. Step 1: Check queue update correctness

   Queue is updated by slicing off first element correctly, no bug here.

2. Step 2: Verify reverse function usage

   reverse(level) is called but no definition or implementation is shown, causing compile error.

3. Final Answer:

   The reverse function is called but not defined or implemented. -> Option A

4. Quick Check:

   Undefined reverse function causes error [OK]

Hint: Ensure all helper functions like reverse are implemented [OK]

Common Mistakes:

• Assuming reverse is built-in in Go
• Ignoring initialization of leftToRight (usually done before loop)
• Misunderstanding queue slicing syntax

5. You want to implement Zigzag Level Order Traversal but optimize space by avoiding reversing slices. Which approach is best?

hard

A. Use a queue and reverse the slice after each level as usual.

B. Use two stacks to alternate pushing nodes in correct order per level.

C. Use recursion with a global list and reverse at the end.

D. Traverse all nodes left-to-right and then reverse the entire result.

Solution

1. Step 1: Understand reversing cost

   Reversing slices after each level adds extra time and space overhead.

2. Step 2: Use two stacks for order control

   Two stacks let you push child nodes in order that naturally produces zigzag traversal without reversing.

3. Final Answer:

   Use two stacks to alternate pushing nodes in correct order per level. -> Option B

4. Quick Check:

   Two stacks avoid reversing slices [OK]

Hint: Two stacks method avoids reversing slices [OK]

Common Mistakes:

• Relying on reversing slices every level
• Using recursion without order control
• Reversing entire result instead of per level