BFS traversal and applications in Data Structures Theory - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding BFS traversal order

Consider an undirected graph where BFS starts from node A. Which of the following sequences correctly represents a possible BFS traversal order?

A A, C, B, E, D

B A, D, B, C, E

C A, B, C, D, E

D A, E, D, C, B

💡 Hint

BFS explores neighbors level by level, visiting all nodes at the current distance before moving further.

BFS visits nodes in order of their distance from the start node. Option C shows a valid level order traversal. Other options mix nodes from different levels.

🚀 Application

intermediate

Shortest path in unweighted graph using BFS

Which BFS property allows it to find the shortest path in an unweighted graph?

A It explores nodes in increasing order of their distance from the start node.

B It uses a stack to remember nodes to visit next.

C It only visits nodes with the highest degree first.

D It visits nodes randomly to find the shortest path.

💡 Hint

Think about how BFS visits nodes layer by layer.

BFS explores nodes by their distance from the start node, so the first time it reaches a node, it has found the shortest path to it.

🔍 Analysis

advanced

BFS traversal on a directed graph with cycles

What happens when BFS is applied to a directed graph containing cycles?

A BFS always terminates immediately without visiting all nodes.

B BFS may enter an infinite loop if visited nodes are not tracked.

C BFS ignores cycles and treats the graph as acyclic.

D BFS cannot be applied to directed graphs.

💡 Hint

Consider what happens if BFS revisits nodes endlessly.

If BFS does not keep track of visited nodes, it can revisit nodes in cycles infinitely. Proper tracking prevents this.

❓ Comparison

advanced

BFS vs DFS in graph traversal

Which statement correctly compares BFS and DFS?

A BFS uses a queue and finds shortest paths in unweighted graphs; DFS uses a stack and explores deeply first.

B DFS uses a queue and finds shortest paths; BFS uses a stack and explores deeply first.

C Both BFS and DFS use stacks and find shortest paths in weighted graphs.

D BFS and DFS are identical in traversal order and data structures used.

💡 Hint

Recall the data structures each algorithm uses and their traversal style.

BFS uses a queue to explore neighbors level by level, useful for shortest paths in unweighted graphs. DFS uses a stack (or recursion) to explore as deep as possible before backtracking.

❓ Reasoning

expert

BFS application in social network analysis

In a social network graph, BFS is used to find all users within 3 degrees of connection from a given user. What is the main reason BFS is suitable for this task?

A BFS uses recursion to explore all possible paths simultaneously.

B BFS randomly jumps between users, quickly finding distant connections.

C BFS only visits direct friends and ignores further connections.

D BFS explores nodes in layers, so it naturally finds all users at each degree of separation efficiently.

💡 Hint

Think about how BFS visits nodes based on their distance from the start node.

BFS visits nodes in order of their distance from the start, making it ideal to find all users within a certain number of connections (degrees).

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