Week 9: Depth-First Search (DFS)

BSCS1001 — IIT Madras BS Degree Prerequisite: Topic 15 (Recursion), Week 7 (Graphs) Cross-links: BSCS2002-PDSA (Week 8 — DFS)

1. Motivation: Exploring a Graph

1. Go to a neighboring station
2. From there, go to another neighbor (deeper)
3. When you can't go deeper, backtrack and try a different neighbor

Real-world analogy: Exploring a maze by always turning right. You go as deep as possible, then backtrack when you hit a dead end.

2. What is DFS?

Key Features

3. DFS Algorithm

Pseudocode

pseudo
Procedure DFS(graph, visited, i)
    // Mark current node as visited
    visited[i] = True
    // Explore all neighbors
    foreach j in columns(graph) {
        if (graph[i][j] == 1 AND not(isKey(visited, j))) {
            visited = DFS(graph, visited, j)
        }
    }
    return(visited)
End DFS

How to Use It

sql
// Initialize
visited = {}
// Start DFS from node 4
visited = DFS(graph, visited, 4)
// keys(visited) contains all nodes reachable from node 4
// If keys(visited) includes all nodes, the graph is connected

The Visited Dictionary

• Key: Node index
• Value: True (visited) Before DFS: visited = {} After DFS from node 4: visited = {4: True, 1: True, 2: True, ...}

4. DFS Tracing Example

Graph

Adjacency Matrix

pseudo
        0  1  2  3  4  5  6  7  8  9  10
    0  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    1  [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0]
    2  [0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0]
    3  [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    4  [0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0]
    5  [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
    6  [0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0]
    7  [0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0]
    8  [0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0]
    9  [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1]
    10 [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]

DFS Call Sequence

The Recursive Call Stack

pseudo
DFS(graph, visited, 4)
  └─ DFS(graph, visited, 1)
       ├─ DFS(graph, visited, 2)
       │    └─ DFS(graph, visited, 5)
       │         └─ return
       │    └─ return
       └─ DFS(graph, visited, 3)
            └─ return
       └─ return
  └─ DFS(graph, visited, 6)
       └─ DFS(graph, visited, 7)
            └─ DFS(graph, visited, 8)
                 └─ DFS(graph, visited, 9)
                      └─ DFS(graph, visited, 10)
                           └─ return
                      └─ return
                 └─ return
            └─ return
       └─ return
  └─ return (final)

5. Connected Components

sql
Procedure IsConnected(graph)
    // Start DFS from node 0
    visited = {}
    visited = DFS(graph, visited, 0)
    // Check if all nodes were visited
    foreach i in rows(graph) {
        if (not(isKey(visited, i))) {
            return(False)    // Node i not reachable from 0
        }
    }
    return(True)
End IsConnected

Finding All Components

sql
Procedure FindAllComponents(graph)
    allVisited = {}
    components = []
    foreach i in rows(graph) {
        if (not(isKey(allVisited, i))) {
            // Start a new component from i
            componentVisited = {}
            componentVisited = DFS(graph, componentVisited, i)
            // Add this component's nodes to overall visited
            foreach v in keys(componentVisited) {
                allVisited[v] = True
            }
            components = components ++ [keys(componentVisited)]
        }
    }
    return(components)
End FindAllComponents

6. DFS vs BFS

7. Practice Questions

Basic Questions

Show Answer

Depth-First Search — a graph traversal algorithm that explores as far as possible along each branch before backtracking. It visits all nodes reachable from the starting node. Q2. Why does DFS need a visited dictionary? Show Answer

Graphs can have cycles (you can go in circles). Without tracking visited nodes, DFS would loop forever, visiting the same nodes repeatedly. The visited dictionary ensures each node is processed only once. Q3. What does isKey(visited, j) check in the DFS pseudocode? Show Answer

It checks if node j has already been visited. If j is NOT in visited, it's unvisited and we should recursively explore it. If j IS in visited, we skip it to avoid cycles. Q4. How does DFS determine if a graph is connected? Show Answer

Start DFS from any node. After DFS finishes, check if all nodes are in the visited dictionary. If yes, the graph is connected (all nodes reachable from the start).

Intermediate Questions

pseudo
1 — 2 — 4
|    |
3 — 5

Show Answer

All 5 nodes visited → graph is connected. Q6. What is backtracking in the context of DFS? Show Answer

Backtracking occurs when DFS reaches a node with no unvisited neighbors. The current recursive call returns, and the previous call resumes — effectively "backing up" to try other branches. This is automatic due to the recursive nature of DFS. Q7. How would you modify DFS to find a path between two nodes (not just reachability)? Show Answer

sql
Procedure FindPathDFS(graph, visited, current, target, path)
    visited[current] = True
    path = path ++ [current]

    if (current == target) {
        return(path)           // Found target!
    }

    foreach j in columns(graph) {
        if (graph[current][j] == 1 AND not(isKey(visited, j))) {
            result = FindPathDFS(graph, visited, j, target, path)
            if (result ≠ []) {
                return(result)  // Path found in this branch
            }
        }
    }

    return([])  // No path found from here
End FindPathDFS

Show Answer

• Use DFS when: You need to explore all nodes, check connectivity, find any path (not necessarily shortest), or memory is limited.
• Use BFS when: You need the shortest path (fewest edges), or the graph is very deep but narrow.

DFS uses a stack (recursion), BFS uses a queue.

Advanced Questions

Show Answer

The visited check prevents infinite looping. Without it, DFS would go 1→2→3→1→2→3→... forever. Q10. What is the time complexity of DFS? Why? Show Answer

Time complexity: O(V + E) where V = vertices, E = edges.

• Each vertex is visited exactly once (the visited check ensures this)
• For each vertex, we examine all its outgoing edges (checking all columns)
• Total: V vertices + E edge checks = O(V + E)

In matrix representation, we check ALL columns for each vertex, so it's O(V²). Q11. Write pseudocode to count the number of connected components in a graph. Show Answer

pseudo
Procedure CountComponents(graph)
    visited = {}
    componentCount = 0

    foreach i in rows(graph) {
        if (not(isKey(visited, i))) {
            // Found a new component
            componentCount = componentCount + 1
            visited = DFS(graph, visited, i)
        }
    }

    return(componentCount)
End CountComponents

Show Answer

In a tree: No cycles exist, so you don't strictly need a visited set (though it doesn't hurt). Every node has exactly one parent, so there's only one way to reach each node.

In a graph: Cycles can exist. You MUST use a visited set to avoid infinite looping. A node may be reachable via multiple paths.

DFS algorithm is the same for both — the visited tracking is what makes it work on general graphs.

📚 Cross-References

Next Topic: 17 — OOP: Encapsulation

Quiz Tip: End Term often asks you to trace DFS call sequences. Practice the "go deep, then backtrack" pattern! Join Discord PreviousRecursionNextOOP — Encapsulation & Abstraction