Graph Traversal — BFS and DFS

🎯 Learning Objectives

1. Implement BFS using a queue data structure
2. Implement DFS using a stack or recursion
3. Compare BFS vs. DFS in terms of space, time, and use cases
4. Apply BFS to find shortest path in unweighted graphs
5. Apply DFS for cycle detection and connectivity

📋 Prerequisites

• Graph Fundamentals — vertices, edges, adjacency list/matrix

📖 Core Content

19.1 Intuition: Two Ways to Explore

• BFS is like a wave: explore all rooms closest to you first, then move outward. You'd see all rooms 1 step away, then all rooms 2 steps away, etc.
• DFS is like exploring one corridor fully before backtracking. You go deep into one wing, then return and try the next.

💡 Why this matters: BFS finds shortest paths in unweighted graphs (like Google Maps for non-weighted roads). DFS is used for topological sorting, cycle detection, and solving mazes.

19.2 Breadth-First Search (BFS)

1. Start from source vertex $s$. Mark $s$ as visited, enqueue it.
2. While queue is not empty:
   • Dequeue vertex $v$
   • Visit each unvisited neighbor $w$ of $v$: mark visited, enqueue $w$
3. All vertices reachable from $s$ are now visited.

text
BFS(G, s):
  visited[s] = true
  queue.enqueue(s)
  while queue not empty:
    v = queue.dequeue()
    for each neighbor w of v:
      if not visited[w]:
        visited[w] = true
        queue.enqueue(w)

• Shortest path in unweighted graphs (the first time BFS reaches a node, it's via the shortest path)
• Web crawling
• Social network "friend-of-friend" distance
• Finding connected components

19.3 Depth-First Search (DFS)

1. Mark current vertex $v$ as visited
2. Recursively visit each unvisited neighbor

text
DFS(G, v):
  visited[v] = true
  for each neighbor w of v:
    if not visited[w]:
      DFS(G, w)

1. Push source $s$ onto stack
2. While stack not empty:
   • Pop $v$
   • If $v$ not visited: mark visited, push all neighbors Time complexity: $O(V + E)$ with adjacency list. Space complexity: $O(V)$ for stack + visited. Applications:

• Topological sorting
• Cycle detection
• Finding connected components
• Solving puzzles/mazes
• Detecting bipartite graphs (Diagram)

19.4 Comparison

19.5 Worked Examples

📐 Key Formulas — Summary Table

⚠️ Common Pitfalls

Pitfall 1: Confusing Queue vs. Stack

Pitfall 2: Forgetting to Mark Visited Before Enqueueing

Pitfall 3: Infinite Loop in DFS Due to Cycles

📝 Practice Questions

Q1: For graph with edges {(1,2),(1,3),(2,4),(3,4)}, what's the BFS order from 1?

$1, 2, 3, 4$

$\boxed{1,2,3,4}$ Q2: What data structure does BFS use?

Queue.

$\boxed{\text{Queue}}$ Q3: What data structure does DFS use?

Stack (or recursion).

$\boxed{\text{Stack}}$ Q4: Which algorithm finds shortest path in unweighted graphs?

BFS.

$\boxed{\text{BFS}}$ Q5: Time complexity of BFS on adjacency list?

$O(V + E)$

$\boxed{O(V+E)}$ Q6: Can DFS be used for topological sorting?

Yes — DFS with a stack to record finish times.

$\boxed{\text{Yes}}$ Q7: For a complete graph $K_n$, how many vertices does BFS visit from any start?

All $n$ vertices.

$\boxed{n}$ Q8: What's the space complexity of BFS in worst case?

$O(V)$ (if all vertices are on the frontier at once).

$\boxed{O(V)}$

🔗 Cross-References

• Previous: Graph Fundamentals
• Next: DAGs & Topological Sort
• Across courses: BSCS1001 Computational Thinking (search algorithms); PDSA (graph algorithms) Join Discord Previous10.1 Graph FundamentalsNext10.3 DAGs & Topological Sorting