Tree Traversal Level Order BFS in DSA Go - Execution Trace

Concept Flow - Tree Traversal Level Order BFS

Start at root node

↓

Add root to queue

↓

While queue not empty

↓

Remove front node from queue

↓

Visit node (process value)

↓

Add left child to queue if exists

↓

Add right child to queue if exists

↓

Repeat loop

↓

Queue empty -> Done

Start from the root, use a queue to visit nodes level by level, adding children to the queue as you go.

Execution Sample

DSA Go

type Node struct {
  Val int
  Left, Right *Node
}

func LevelOrder(root *Node) []int {
  if root == nil {
    return []int{}
  }
  queue := []*Node{root}
  var 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
}

This code visits each node in the tree level by level using a queue and collects their values.

Execution Table

Step	Operation	Node Visited	Queue Before	Queue After	Visual State
1	Start with root	1	[]	[1]	1 / \ 2 3
2	Dequeue node	1	[1]	[]	1 / \ 2 3
3	Visit node	1	[]	[]	Visited: 1
4	Enqueue left child	1	[]	[2]	Queue: 2
5	Enqueue right child	1	[2]	[2,3]	Queue: 2 -> 3
6	Dequeue node	2	[2,3]	[3]	Queue: 3
7	Visit node	2	[3]	[3]	Visited: 1, 2
8	Enqueue left child	2	[3]	[3,4]	Queue: 3 -> 4
9	Enqueue right child	2	[3,4]	[3,4,5]	Queue: 3 -> 4 -> 5
10	Dequeue node	3	[3,4,5]	[4,5]	Queue: 4 -> 5
11	Visit node	3	[4,5]	[4,5]	Visited: 1, 2, 3
12	Enqueue left child	3	[4,5]	[4,5]	No left child
13	Enqueue right child	3	[4,5]	[4,5,6]	Queue: 4 -> 5 -> 6
14	Dequeue node	4	[4,5,6]	[5,6]	Queue: 5 -> 6
15	Visit node	4	[5,6]	[5,6]	Visited: 1, 2, 3, 4
16	Enqueue left child	4	[5,6]	[5,6]	No left child
17	Enqueue right child	4	[5,6]	[5,6]	No right child
18	Dequeue node	5	[5,6]	[6]	Queue: 6
19	Visit node	5	[6]	[6]	Visited: 1, 2, 3, 4, 5
20	Enqueue left child	5	[6]	[6]	No left child
21	Enqueue right child	5	[6]	[6]	No right child
22	Dequeue node	6	[6]	[]	Queue: empty
23	Visit node	6	[]	[]	Visited: 1, 2, 3, 4, 5, 6
24	Enqueue left child	6	[]	[]	No left child
25	Enqueue right child	6	[]	[]	No right child
26	Queue empty	-	[]	[]	Traversal complete

💡 Queue is empty, all nodes visited

Variable Tracker

Variable	Start	After Step 1	After Step 5	After Step 9	After Step 13	After Step 17	After Step 21	After Step 25	Final
queue	[]	[1]	[2,3]	[3,4,5]	[4,5,6]	[5,6]	[6]	[]	[]
visited_nodes	[]	[1]	[1]	[1,2]	[1,2,3]	[1,2,3,4]	[1,2,3,4,5]	[1,2,3,4,5,6]	[1,2,3,4,5,6]

Key Moments - 3 Insights

Why do we add children to the queue after visiting the node?

Because in BFS, we visit nodes level by level. Adding children after visiting ensures we process all nodes at the current level before moving deeper. See steps 4,5 and 8,9 where children are added after visiting.

Why does the loop stop when the queue is empty?

The queue holds nodes to visit. When empty, no nodes remain to process, so traversal is complete. This is shown at step 26 where the queue is empty and traversal ends.

Why do we remove the node from the front of the queue each time?

Removing from the front ensures nodes are visited in the order they were added, preserving level order. See steps 2,6,10 where nodes are dequeued from the front.

Visual Quiz - 3 Questions

Look at the execution table, what is the queue after step 9?

A [4,5]

B [3,4,5]

C [2,3]

D [5,6]

💡 Hint

Check the 'Queue After' column at step 9 in the execution_table.

At which step does the queue become empty?

A Step 26

B Step 18

C Step 22

D Step 2

💡 Hint

Look for the step where 'Queue After' is empty and traversal ends.

If node 3 had no right child, how would the queue after step 13 change?

A [5,6]

B [4,5,6]

C [4,5]

D [3,4,5]

💡 Hint

Step 13 shows enqueueing right child of node 3; if missing, queue won't include 6.

Concept Snapshot

Level Order BFS visits tree nodes level by level.
Use a queue to hold nodes to visit.
Start by enqueueing root.
While queue not empty: dequeue, visit, enqueue children.
Stops when queue is empty.
Result is nodes in level order.

Full Transcript

Level Order BFS starts at the root node and uses a queue to visit nodes level by level. Initially, the root is added to the queue. Then, while the queue is not empty, the node at the front is removed and visited. Its children, if any, are added to the back of the queue. This process repeats until no nodes remain in the queue, meaning all nodes have been visited in level order. The execution table shows each step, including queue changes and visited nodes. The variable tracker records the queue and visited nodes after key steps. Key moments clarify why children are added after visiting, why the loop stops when the queue is empty, and why nodes are dequeued from the front to maintain order. The visual quiz tests understanding of queue states and effects of missing children. The concept snapshot summarizes the BFS traversal process clearly and simply.

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