Tree Traversal Level Order BFS in DSA Go

Mental Model

We visit tree nodes level by level from top to bottom, left to right, like reading lines in a book.

Analogy: Imagine a family photo where you first see parents, then children, then grandchildren, all in rows from top to bottom.

      1
     / \
    2   3
   / \   \
  4   5   6

Level order: 1 → 2 → 3 → 4 → 5 → 6 → null

Dry Run Walkthrough

Input: Tree: 1 with children 2 and 3; 2 has children 4 and 5; 3 has child 6

Goal: Print nodes level by level from top to bottom, left to right

Step 1: Start with root node 1 in queue

Queue: [1]
Output: []

Why: We begin traversal from the root node

Step 2: Remove 1 from queue, print it, add its children 2 and 3 to queue

Queue: [2, 3]
Output: [1]

Why: Visit root, then prepare to visit next level nodes

Step 3: Remove 2 from queue, print it, add its children 4 and 5 to queue

Queue: [3, 4, 5]
Output: [1, 2]

Why: Visit left child of root, add its children for next level

Step 4: Remove 3 from queue, print it, add its child 6 to queue

Queue: [4, 5, 6]
Output: [1, 2, 3]

Why: Visit right child of root, add its child for next level

Step 5: Remove 4 from queue, print it, no children to add

Queue: [5, 6]
Output: [1, 2, 3, 4]

Why: Visit next node at level 3, no children to add

Step 6: Remove 5 from queue, print it, no children to add

Queue: [6]
Output: [1, 2, 3, 4, 5]

Why: Visit next node at level 3, no children to add

Step 7: Remove 6 from queue, print it, no children to add

Queue: []
Output: [1, 2, 3, 4, 5, 6]

Why: Visit last node, queue empty means traversal done

Result:

Output: 1 → 2 → 3 → 4 → 5 → 6 → null

Annotated Code

DSA Go

package main

import (
	"fmt"
)

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

func levelOrder(root *TreeNode) {
	if root == nil {
		return
	}
	queue := []*TreeNode{root} // start with root in queue
	for len(queue) > 0 {
		current := queue[0]       // get first node in queue
		queue = queue[1:]         // remove it from queue
		fmt.Printf("%d -> ", current.Val) // print current node
		if current.Left != nil {
			queue = append(queue, current.Left) // add left child
		}
		if current.Right != nil {
			queue = append(queue, current.Right) // add right child
		}
	}
	fmt.Print("null\n")
}

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

	levelOrder(root)
}

queue := []*TreeNode{root} // start with root in queue

initialize queue with root node to start level order traversal

current := queue[0] // get first node in queue

select node at front of queue to visit

queue = queue[1:] // remove it from queue

remove visited node from queue to move forward

fmt.Printf("%d -> ", current.Val) // print current node

output current node value in traversal order

if current.Left != nil { queue = append(queue, current.Left) // add left child }

enqueue left child if exists for next level

if current.Right != nil { queue = append(queue, current.Right) // add right child }

enqueue right child if exists for next level

Output

1 -> 2 -> 3 -> 4 -> 5 -> 6 -> null

Complexity Analysis

Time: O(n) because each node is visited exactly once

Space: O(n) because in worst case queue holds all nodes at one level

vs Alternative: Compared to recursive DFS, BFS uses a queue and visits nodes level by level, which can use more memory but is better for level-based problems

Edge Cases

empty tree (root is nil)

function returns immediately without printing

DSA Go

if root == nil {
	return
}

tree with single node

prints the single node value followed by null

DSA Go

queue := []*TreeNode{root} // start with root in queue

tree where some nodes have only one child

only existing children are added to queue, traversal continues correctly

DSA Go

if current.Left != nil {
	queue = append(queue, current.Left)
}

When to Use This Pattern

When a problem asks to visit nodes level by level or find shortest path in a tree, use level order BFS with a queue to process nodes in order.

Common Mistakes

Mistake: Forgetting to remove the current node from the queue after visiting
Fix: Remove the first element from the queue after processing it to avoid infinite loops

Mistake: Adding children to queue before printing current node
Fix: Print the current node before adding its children to maintain correct order

Summary

Visits all nodes in a tree level by level from top to bottom, left to right.

Use when you need to process or print nodes in order of their depth or level.

The key is to use a queue to hold nodes of the current level before moving to the next.

Practice

1. What does Level Order Traversal (BFS) of a binary tree do?

easy

A. Visits nodes in postorder (left, right, root)

B. Visits nodes in preorder (root, left, right)

C. Visits nodes in inorder (left, root, right)

D. Visits nodes level by level from top to bottom, left to right

Solution

1. Step 1: Understand Level Order Traversal

   Level order traversal visits nodes one level at a time, starting from the root and moving down each level from left to right.

2. Step 2: Compare with other traversals

   Preorder, inorder, and postorder are depth-first traversals, not level by level.

3. Final Answer:

   Visits nodes level by level from top to bottom, left to right -> Option D

4. Quick Check:

   Level order = BFS = level by level [OK]

Hint: Level order means visit nodes by levels, top to bottom [OK]

Common Mistakes:

• Confusing level order with preorder traversal
• Thinking level order visits nodes depth-first
• Mixing up left-to-right with right-to-left order

2. Which Go code snippet correctly initializes a queue for BFS traversal of a binary tree?

easy

A. queue := make(TreeNode)

B. queue := []*TreeNode{}

C. queue := TreeNode{}

D. queue := []TreeNode

Solution

1. Step 1: Identify correct queue initialization

   In Go, a queue for BFS is usually a slice of pointers to TreeNode, so []*TreeNode{} initializes an empty slice correctly.

2. Step 2: Check other options

   make(TreeNode) is invalid because make is for slices, maps, channels, not structs. TreeNode{} is a struct instance, not a queue. []TreeNode is a slice type declaration missing initialization.

3. Final Answer:

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

4. Quick Check:

   Queue for BFS = slice of *TreeNode [OK]

Hint: Use slice of pointers []*TreeNode{} for BFS queue [OK]

Common Mistakes:

• Using make with struct type instead of slice
• Declaring slice type without initialization
• Using struct instance instead of slice

3. What is the output of the following Go code performing level order traversal on this tree?

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

func levelOrder(root *TreeNode) []int {
  if root == nil {
    return []int{}
  }
  queue := []*TreeNode{root}
  result := []int{}
  for len(queue) > 0 {
    node := queue[0]
    queue = queue[1:]
    result = append(result, node.Val)
    if node.Left != nil {
      queue = append(queue, node.Left)
    }
    if node.Right != nil {
      queue = append(queue, node.Right)
    }
  }
  return result
}

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

fmt.Println(levelOrder(root))

medium

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

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

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

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

Solution

1. Step 1: Trace the BFS queue processing

   Start with queue=[1]. Visit 1, enqueue 2 and 3. Queue=[2,3]. Visit 2, enqueue 4 and 5. Queue=[3,4,5]. Visit 3 (no children). Queue=[4,5]. Visit 4 (no children). Queue=[5]. Visit 5 (no children). Queue empty.

2. Step 2: Collect visited nodes in order

   Visited nodes in order: 1, 2, 3, 4, 5.

3. Final Answer:

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

4. Quick Check:

   BFS visits nodes level-wise: 1,2,3,4,5 [OK]

Hint: Follow queue order: enqueue children left then right [OK]

Common Mistakes:

• Visiting right child before left child
• Confusing BFS with DFS order
• Forgetting to append children to queue

4. The following Go code for level order traversal has a bug. What is the error?

func levelOrder(root *TreeNode) []int {
  if root == nil {
    return []int{}
  }
  queue := []*TreeNode{root}
  result := []int{}
  for len(queue) > 0 {
    node := queue[0]
    // Missing queue update here
    result = append(result, node.Val)
    if node.Left != nil {
      queue = append(queue, node.Left)
    }
    if node.Right != nil {
      queue = append(queue, node.Right)
    }
  }
  return result
}

medium

A. The root node is never added to the queue

B. Children nodes are not appended to the queue

C. The queue is never shortened, causing an infinite loop

D. The result slice is not initialized

Solution

1. Step 1: Identify queue update in BFS loop

   In BFS, after processing the first node, it must be removed from the queue (queue = queue[1:]). This code misses that step.

2. Step 2: Consequence of missing queue update

   Without removing the first node, the queue length never decreases, causing an infinite loop.

3. Final Answer:

   The queue is never shortened, causing an infinite loop -> Option C

4. Quick Check:

   Queue must shrink each iteration [OK]

Hint: Always remove processed node from queue in BFS loop [OK]

Common Mistakes:

• Forgetting to dequeue the current node
• Appending children incorrectly
• Not initializing result slice

5. Given a binary tree, how can you modify level order traversal to return a list of lists, where each inner list contains nodes at that level only? Which approach is correct in Go? A) Use a queue and track the number of nodes at current level, dequeue exactly that many nodes, then enqueue their children. B) Use recursion to visit nodes and append values to a global list. C) Use a stack instead of a queue to reverse the order. D) Traverse the tree inorder and group nodes by their depth using a map.

hard

A. Use a queue and track nodes count per level, process level by level

B. Use recursion and append nodes to a single list

C. Use a stack to reverse traversal order

D. Use inorder traversal and group nodes by depth in a map

Solution

1. Step 1: Understand level grouping in BFS

   To group nodes by level, track how many nodes are at the current level (queue length before processing), then dequeue exactly that many nodes and collect their values.

2. Step 2: Why other options are incorrect

   Recursion without level tracking won't separate levels. Stack reverses order but doesn't group levels. Inorder traversal visits nodes depth-first, not level-wise, so grouping by depth is complex and not BFS.

3. Final Answer:

   Use a queue and track nodes count per level, process level by level -> Option A

4. Quick Check:

   Level order + count nodes per level = grouped levels [OK]

Hint: Count nodes in queue before each level to group them [OK]

Common Mistakes:

• Using recursion without level tracking
• Using stack instead of queue for BFS
• Trying inorder traversal for level grouping