Zigzag Level Order Traversal in DSA Go - Build from Scratch

Zigzag Level Order Traversal

📖 Scenario: Imagine you have a family tree represented as a binary tree. You want to visit each generation, but in a zigzag way: first generation from left to right, second from right to left, and so on. This helps you see the family members in a fun pattern.

🎯 Goal: Build a program that takes a binary tree and prints its nodes in zigzag level order traversal.

📋 What You'll Learn

Create a binary tree using the given TreeNode struct

Use a queue to traverse the tree level by level

Alternate the order of nodes at each level (left to right, then right to left)

Print the final zigzag traversal as a slice of slices

💡 Why This Matters

🌍 Real World

Zigzag traversal is useful in scenarios like visualizing hierarchical data with alternating directions for better readability.

💼 Career

Understanding tree traversals and queue usage is essential for software engineering roles involving data structures, algorithms, and system design.

1

Create the binary tree

Create the binary tree nodes using the TreeNode struct with these exact values and connections: root node with Val: 1, left child with Val: 2, right child with Val: 3, left child of node 2 with Val: 4, and right child of node 3 with Val: 5. Assign the root node to a variable called root.

DSA Go

package main

import "fmt"

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func main() {
    // Create the binary tree nodes and assign to root
    // Your code here
}

Hint

Use the &TreeNode{Val: value} syntax to create nodes and assign children using Left and Right fields.

2

Initialize traversal variables

Create a variable called results as a slice of slices of integers to store the final zigzag traversal. Also create a variable called leftToRight of type bool and set it to true to track the direction of traversal.

DSA Go

package main

import "fmt"

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func main() {
    root := &TreeNode{Val: 1}
    root.Left = &TreeNode{Val: 2}
    root.Right = &TreeNode{Val: 3}
    root.Left.Left = &TreeNode{Val: 4}
    root.Right.Right = &TreeNode{Val: 5}

    // Create results slice and leftToRight boolean
    // Your code here
}

Hint

Use results := [][]int{} to create an empty slice of slices and leftToRight := true to start with left to right direction.

3

Implement zigzag level order traversal

Use a queue slice of *TreeNode called queue initialized with root. Use a for loop that runs while len(queue) > 0. Inside the loop, create a slice level to store node values of the current level. Use a for loop to iterate exactly len(queue) times, popping nodes from the front of queue. Append their values to level. Add their children to the end of queue. After the inner loop, if leftToRight is false, reverse the level slice. Append level to results. Flip the leftToRight boolean to its opposite value.

DSA Go

package main

import "fmt"

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func main() {
    root := &TreeNode{Val: 1}
    root.Left = &TreeNode{Val: 2}
    root.Right = &TreeNode{Val: 3}
    root.Left.Left = &TreeNode{Val: 4}
    root.Right.Right = &TreeNode{Val: 5}

    results := [][]int{}
    leftToRight := true

    // Implement zigzag traversal using queue and loops
    // Your code here
}

Hint

Use a queue slice to hold nodes. Pop from front and append children to back. Reverse the level slice when direction is right to left.

4

Print the zigzag traversal result

Print the results variable using fmt.Println(results) to display the zigzag level order traversal.

DSA Go

package main

import "fmt"

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func main() {
    root := &TreeNode{Val: 1}
    root.Left = &TreeNode{Val: 2}
    root.Right = &TreeNode{Val: 3}
    root.Left.Left = &TreeNode{Val: 4}
    root.Right.Right = &TreeNode{Val: 5}

    results := [][]int{}
    leftToRight := true

    queue := []*TreeNode{root}

    for len(queue) > 0 {
        levelSize := len(queue)
        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 {
            for i, j := 0, len(level)-1; i < j; i, j = i+1, j-1 {
                level[i], level[j] = level[j], level[i]
            }
        }

        results = append(results, level)
        leftToRight = !leftToRight
    }

    // Print the results slice
    // Your code here
}

Hint

Use fmt.Println(results) to print the final zigzag traversal.

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