BFS traversal and applications in Data Structures Theory - Step-by-Step Execution

Concept Flow - BFS traversal and applications

Start at source node

↓

Mark source as visited

↓

Add source to queue

↓

While queue not empty

↓

Dequeue node

↓

Visit all unvisited neighbors

↓

Mark neighbors visited and enqueue

↓

Repeat loop

↓

End

Start from a node, visit neighbors level by level using a queue until all reachable nodes are visited.

Execution Sample

Data Structures Theory

graph = { 'A': ['B', 'C'], 'B': ['A', 'D'], 'C': ['A', 'D'], 'D': ['B', 'C'] }
visited = set()
queue = ['A']
visited.add('A')
while queue:
  node = queue.pop(0)
  for neighbor in graph[node]:
    if neighbor not in visited:
      visited.add(neighbor)
      queue.append(neighbor)

Perform BFS starting from node 'A' visiting nodes in breadth-first order.

Analysis Table

Step	Current Node	Queue Before	Visited Before	Neighbors Checked	Neighbors Added	Queue After	Visited After
1	A	['A']	{'A'}	B, C	B, C	['B', 'C']	{'A', 'B', 'C'}
2	B	['B', 'C']	{'A', 'B', 'C'}	A, D	D	['C', 'D']	{'A', 'B', 'C', 'D'}
3	C	['C', 'D']	{'A', 'B', 'C', 'D'}	A, D		['D']	{'A', 'B', 'C', 'D'}
4	D	['D']	{'A', 'B', 'C', 'D'}	B, C		[]	{'A', 'B', 'C', 'D'}
5	-	[]	{'A', 'B', 'C', 'D'}	-	-	[]	{'A', 'B', 'C', 'D'}

💡 Queue is empty, all reachable nodes visited.

State Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
queue	['A']	['B', 'C']	['C', 'D']	['D']	[]	[]
visited	{'A'}	{'A', 'B', 'C'}	{'A', 'B', 'C', 'D'}	{'A', 'B', 'C', 'D'}	{'A', 'B', 'C', 'D'}	{'A', 'B', 'C', 'D'}
current_node	None	A	B	C	D	None

Key Insights - 3 Insights

Why do we add neighbors to the queue only if they are not visited?

To avoid visiting the same node multiple times and prevent infinite loops, as shown in steps 2 and 3 where neighbors already visited are skipped.

Why does the queue shrink and eventually become empty?

Because nodes are dequeued after visiting, and no new nodes are added once all neighbors are visited, as seen in step 4 and exit at step 5.

Why do we mark the starting node 'A' as visited before the loop?

To prevent it from being re-enqueued via back edges from neighbors (e.g., B to A), ensuring each node is enqueued only once and processed properly in breadth-first order, as shown in steps 2 and 3 where A is skipped.

Visual Quiz - 3 Questions

Look at the execution table at Step 2. What nodes are in the queue after processing node 'B'?

A ['B', 'C', 'D']

B ['C', 'D']

C ['D']

D ['A', 'D']

💡 Hint

Check the 'Queue After' column in Step 2 of the execution table.

At which step does the queue become empty, ending the BFS?

A Step 5

B Step 3

C Step 4

D Step 2

💡 Hint

Look at the 'Queue Before' and 'Queue After' columns to find when the queue is empty.

If we add 'A' to visited before starting, how would the neighbors added at Step 1 change?

A No neighbors would be added

B Neighbors 'B' and 'C' would not be added because 'A' is visited

C Only 'B' and 'C' would be added as before

D Neighbors 'B' and 'C' would still be added

💡 Hint

Check how visited nodes affect neighbor addition in the execution table.

Concept Snapshot

BFS (Breadth-First Search) visits nodes level by level.
Use a queue to track nodes to visit.
Mark nodes visited to avoid repeats.
Start from a source node, enqueue neighbors.
Dequeue nodes, visit neighbors until queue empty.
Useful for shortest path, connectivity, and level order traversal.

Full Transcript

Breadth-First Search (BFS) starts at a chosen node and explores all its neighbors before moving to the next level neighbors. It uses a queue to keep track of nodes to visit next and a visited set to avoid revisiting nodes. The process continues until all reachable nodes are visited, ensuring a level-by-level traversal. This method is useful in finding shortest paths in unweighted graphs, checking connectivity, and traversing trees or graphs in a systematic way.

Practice

1. What is the main data structure used in BFS (Breadth-First Search) traversal of a graph?

easy

A. Queue

B. Stack

C. Priority Queue

D. Hash Map

Solution

1. Step 1: Understand BFS traversal method

   BFS explores nodes level by level, which requires processing nodes in the order they are discovered.

2. Step 2: Identify the suitable data structure

   A queue follows First-In-First-Out (FIFO) order, perfect for level-wise exploration in BFS.

3. Final Answer:

   Queue -> Option A

4. Quick Check:

   BFS uses a queue = Queue [OK]

Hint: BFS uses FIFO order, so it needs a queue [OK]

Common Mistakes:

• Confusing BFS with DFS which uses a stack
• Thinking BFS uses a priority queue
• Assuming BFS uses a hash map as main structure

2. Which of the following is the correct way to mark a node as visited in BFS to avoid revisiting it?

easy

A. Add node to a stack after visiting

B. Add node to a visited set or list immediately when enqueued

C. Add node to the queue only after processing all neighbors

D. Do not mark nodes; revisit all nodes

Solution

1. Step 1: Understand when to mark nodes visited in BFS

   Nodes should be marked visited when they are enqueued to prevent multiple enqueues of the same node.

2. Step 2: Identify correct marking method

   Adding nodes to a visited set immediately when enqueued ensures no duplicates in the queue.

3. Final Answer:

   Add node to a visited set or list immediately when enqueued -> Option B

4. Quick Check:

   Mark visited on enqueue = Add node to a visited set or list immediately when enqueued [OK]

Hint: Mark nodes visited when enqueued, not after dequeued [OK]

Common Mistakes:

• Marking nodes visited only after dequeuing
• Using a stack instead of a visited set
• Not marking nodes visited at all

3. Consider the following graph edges:
0 - 1, 0 - 2, 1 - 3, 2 - 3
If BFS starts at node 0, what is the order of nodes visited?

medium

A. [0, 1, 2, 3]

B. [0, 2, 1, 3]

C. [0, 3, 1, 2]

D. [1, 0, 2, 3]

Solution

1. Step 1: Start BFS from node 0

   Enqueue 0, visited order starts with 0.

2. Step 2: Enqueue neighbors of 0 in order

   Neighbors are 1 and 2, enqueue 1 then 2.

3. Step 3: Dequeue 1 and enqueue its neighbor 3

   3 is neighbor of 1, enqueue 3.

4. Step 4: Dequeue 2, neighbor 3 already visited

   No new nodes added.

5. Step 5: Dequeue 3, no new neighbors

   Traversal ends.

6. Final Answer:

   [0, 1, 2, 3] -> Option A

7. Quick Check:

   BFS order = [0, 1, 2, 3] [OK]

Hint: Visit neighbors in order they appear, enqueue before dequeue [OK]

Common Mistakes:

• Visiting neighbors in wrong order
• Adding nodes multiple times
• Starting BFS from wrong node

4. The following BFS code snippet has a bug. What is the error?

visited = set()
queue = [start]
visited.add(start)
while queue:
    node = queue.pop()
    for neighbor in graph[node]:
        if neighbor not in visited:
            queue.append(neighbor)
            visited.add(neighbor)

medium

A. Not marking start node as visited before loop

B. Queue should be a stack for BFS

C. Visited nodes added after enqueueing neighbors

D. Using pop() removes from the end, causing DFS behavior

Solution

1. Step 1: Analyze queue operations

   pop() without argument removes last element, making it LIFO (stack), not FIFO (queue).

2. Step 2: Understand BFS requires FIFO

   BFS needs to remove from front (pop(0)) to process nodes level by level.

3. Final Answer:

   Using pop() removes from the end, causing DFS behavior -> Option D

4. Quick Check:

   pop() without index = DFS, not BFS [OK]

Hint: Use pop(0) for queue behavior in BFS [OK]

Common Mistakes:

• Using pop() instead of pop(0)
• Forgetting to mark start node visited
• Confusing stack and queue roles

5. You want to find the shortest path in an unweighted graph from node A to node B using BFS. Which of the following modifications is necessary to track the actual path?

hard

A. Run BFS twice, once from A and once from B, then combine results

B. Use a stack instead of a queue to track the path

C. Store each node's parent when enqueuing it, then backtrack from B to A

D. Mark nodes visited only after dequeuing them

Solution

1. Step 1: Understand BFS finds shortest path length

   BFS explores nodes level by level, so the first time B is found is shortest path length.

2. Step 2: Track path by storing parents

   When a node is enqueued, record which node led to it (its parent). After BFS, backtrack from B to A using parents.

3. Final Answer:

   Store each node's parent when enqueuing it, then backtrack from B to A -> Option C

4. Quick Check:

   Parent tracking + backtrack = shortest path [OK]

Hint: Save parents on enqueue, backtrack from target [OK]

Common Mistakes:

• Using stack instead of queue for BFS
• Marking visited too late causing duplicates
• Running BFS twice unnecessarily