BFS traversal and applications in Data Structures Theory - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does BFS stand for in graph theory?

BFS stands for Breadth-First Search, a method to explore nodes in a graph level by level.

beginner

How does BFS explore nodes in a graph?

BFS explores nodes by visiting all neighbors of a node before moving to the next level neighbors, using a queue to keep track.

beginner

Name one common data structure used in BFS and explain why.

A queue is used in BFS because it helps process nodes in the order they are discovered, ensuring level-by-level traversal.

beginner

What is one key application of BFS in real life?

BFS is used in finding the shortest path in unweighted graphs, such as finding the shortest route on a map.

intermediate

Why is BFS preferred over DFS for shortest path in unweighted graphs?

Because BFS explores nodes level by level, it finds the shortest path in terms of number of edges, while DFS might go deep and miss shorter paths.

What data structure does BFS primarily use to keep track of nodes to visit?

A Hash Table

B Stack

C Priority Queue

D Queue

BFS uses a queue to process nodes in the order they are discovered, ensuring level-by-level traversal.

Which of the following is a typical application of BFS?

A Finding shortest path in an unweighted graph

B Sorting numbers

C Balancing a binary tree

D Finding maximum value in a list

BFS is commonly used to find the shortest path in unweighted graphs by exploring neighbors level by level.

In BFS, what happens after visiting all neighbors of a node?

A The algorithm moves to the next node in the queue

B The algorithm stops

C The algorithm backtracks to the previous node

D The algorithm sorts the neighbors

After visiting all neighbors, BFS moves to the next node in the queue to continue level-wise exploration.

Which traversal method is better for finding the shortest path in an unweighted graph?

A DFS

B BFS

C Preorder traversal

D Inorder traversal

BFS finds the shortest path in unweighted graphs because it explores nodes level by level.

What is the time complexity of BFS for a graph with V vertices and E edges?

A O(V^2)

B O(E^2)

C O(V + E)

D O(log V)

BFS visits every vertex and edge once, so its time complexity is O(V + E).

Explain how BFS works step-by-step on a simple graph.

Think about how you would explore friends in a social network starting from one person.

Describe two real-life applications where BFS is useful and why.

Consider situations where you want to explore things closest first before going deeper.

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