Tree Traversal Level Order BFS in DSA Go - Build from Scratch

Tree Traversal Level Order BFS

📖 Scenario: Imagine you have a family tree and you want to visit each generation one by one, starting from the oldest ancestor down to the youngest children.

🎯 Goal: You will build a program that visits nodes of a tree level by level using Breadth-First Search (BFS) and prints the values in order.

📋 What You'll Learn

Create a simple binary tree with exact node values

Use a queue to help with level order traversal

Implement BFS to visit nodes level by level

Print the node values in the order they are visited

💡 Why This Matters

🌍 Real World

Level order traversal is useful in scenarios like printing organizational charts, family trees, or spreading information layer by layer in networks.

💼 Career

Understanding BFS and tree traversal is important for software engineers working with hierarchical data, search algorithms, and many coding interviews.

1

Create the binary tree nodes

Create a binary tree with a root node called root of type *Node. The root node should have the value 1. It should have a left child with value 2 and a right child with value 3. The left child of the root should have two children: left child with value 4 and right child with value 5. Use the Node struct defined below.

DSA Go

package main

import "fmt"

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

func main() {
    // Create the tree nodes as described
    // Your code here
}

Hint

Use the &Node{Val: value} syntax to create nodes and assign them to Left and Right fields.

2

Create a queue to help with BFS

Create a slice of *Node called queue and initialize it with the root node inside it. This queue will help us visit nodes level by level.

DSA Go

package main

import "fmt"

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

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

    // Create a queue slice with root node
    // Your code here
}

Hint

Initialize queue as a slice containing only the root node.

3

Implement BFS to traverse the tree level by level

Use a for loop that runs while len(queue) > 0. Inside the loop, remove the first node from queue and store it in current. Then, if current.Left is not nil, append it to queue. Similarly, if current.Right is not nil, append it to queue. Print the value of current.Val inside the loop.

DSA Go

package main

import "fmt"

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

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

    queue := []*Node{root}

    // Implement BFS loop here
    // Your code here
}

Hint

Use a loop to remove the first node from queue, print its value, then add its children to the end of queue.

4

Print the final output of BFS traversal

Run the program to print the values of the nodes in level order separated by spaces. The expected output is: 1 2 3 4 5

DSA Go

package main

import "fmt"

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

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

    queue := []*Node{root}

    for len(queue) > 0 {
        current := queue[0]
        queue = queue[1:]

        fmt.Print(current.Val, " ")

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

    // Output is printed inside the loop
    // Your code here
}

Hint

Run the program to see the node values printed in level order separated by spaces.

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