Shortest Path in Unweighted Graph Using BFS in DSA C - Time & Space Complexity

Time Complexity: Shortest Path in Unweighted Graph Using BFS

O(n + m)

Understanding Time Complexity

We want to understand how long it takes to find the shortest path in an unweighted graph using BFS.

How does the time grow as the graph gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

void bfsShortestPath(int start, int n, vector<vector<int>> &adj) {
    vector<int> dist(n, -1);
    queue<int> q;
    dist[start] = 0;
    q.push(start);
    while (!q.empty()) {
        int u = q.front(); q.pop();
        for (int v : adj[u]) {
            if (dist[v] == -1) {
                dist[v] = dist[u] + 1;
                q.push(v);
            }
        }
    }
}
    

This code finds the shortest distance from a start node to all other nodes in an unweighted graph using BFS.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Visiting each node and checking its neighbors.
• How many times: Each node is visited once, and each edge is checked once.

How Execution Grows With Input

As the graph grows, the time to visit nodes and edges grows roughly with the number of nodes plus edges.

Input Size (n)	Approx. Operations
10 nodes, 15 edges	About 25 operations (10 nodes + 15 edges)
100 nodes, 200 edges	About 300 operations (100 + 200)
1000 nodes, 5000 edges	About 6000 operations (1000 + 5000)

Pattern observation: The operations grow linearly with the number of nodes and edges combined.

Final Time Complexity

Time Complexity: O(n + m)

This means the time grows linearly with the total number of nodes (n) and edges (m) in the graph.

Common Mistake

[X] Wrong: "BFS takes O(n²) time because it uses nested loops."

[OK] Correct: BFS visits each node and edge only once, so it does not check all pairs of nodes. The loops are over neighbors, not all nodes.

Interview Connect

Understanding BFS time complexity helps you explain how graph searches scale and why BFS is efficient for shortest paths in unweighted graphs.

Self-Check

"What if the graph was represented using an adjacency matrix instead of adjacency lists? How would the time complexity change?"

Practice

1. What does BFS (Breadth-First Search) help find in an unweighted graph?

easy

A. The total number of nodes in the graph

B. The shortest path from a start node to all other nodes

C. The longest path between two nodes

D. The heaviest edge in the graph

Solution

1. Step 1: Understand BFS traversal

   BFS explores nodes level by level starting from the source node, visiting all neighbors before moving deeper.

2. Step 2: BFS finds shortest paths in unweighted graphs

   Because BFS visits nodes in order of increasing distance, it finds the shortest path in terms of edges from the start node.

3. Final Answer:

   The shortest path from a start node to all other nodes -> Option B

4. Quick Check:

   BFS = shortest path in unweighted graph [OK]

Hint: BFS explores neighbors level-wise to find shortest paths [OK]

Common Mistakes:

• Confusing BFS with DFS for shortest path
• Thinking BFS finds longest path
• Assuming BFS works only for weighted graphs

2. Which of the following is the correct way to initialize a queue for BFS in C?

easy

A. int queue[MAX]; int front = 0, rear = 0;

B. queue<int> q; // C++ syntax

C. Queue q = new Queue(); // Java syntax

D. var q = []; // JavaScript syntax

Solution

1. Step 1: Identify C syntax for queue

   C does not have built-in queue; we use arrays with front and rear indices to simulate queue.

2. Step 2: Check options for C correctness

   int queue[MAX]; int front = 0, rear = 0; uses array and indices, which is valid in C. Others use non-C syntax.

3. Final Answer:

   int queue[MAX]; int front = 0, rear = 0; -> Option A

4. Quick Check:

   C queue uses array + front/rear indices [OK]

Hint: Use array with front/rear for queue in C [OK]

Common Mistakes:

• Using C++ or Java syntax in C code
• Not initializing front and rear indices
• Assuming queue is built-in in C

3. What is the output distance array after running BFS from node 0 on this graph?

Graph edges:
0 - 1
0 - 2
1 - 3
2 - 3
3 - 4

Assume nodes are 0 to 4 and distance to unreachable nodes is -1.

medium

A. [0, 1, 2, 3, 4]

B. [0, 1, 1, 1, 2]

C. [0, 1, 1, 2, 3]

D. [0, -1, -1, -1, -1]

Solution

1. Step 1: Start BFS from node 0 and set distance[0] = 0

   Initialize distances: distance[0]=0, others = -1.

2. Step 2: Visit neighbors level-wise

   Neighbors of 0: 1 and 2 get distance 1. Then neighbors of 1 and 2: node 3 gets distance 2. Finally, neighbor of 3: node 4 gets distance 3.

3. Final Answer:

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

4. Quick Check:

   Distances increase by 1 per BFS level [OK]

Hint: Distance increments by 1 each BFS level from start [OK]

Common Mistakes:

• Assigning wrong distances to nodes
• Confusing BFS with DFS order
• Not initializing unreachable nodes to -1

4. Identify the bug in this BFS code snippet for shortest path:

void bfs(int start) {
  queue[rear++] = start;
  visited[start] = 1;
  distance[start] = 0;
  while(front < rear) {
    int u = queue[front++];
    for(int v : adj[u]) {
      if(!visited[v]) {
        visited[v] = 1;
        distance[v] = distance[u] + 1;
        queue[rear++] = v;
      }
    }
  }
}

medium

A. Not marking start node as visited

B. Not initializing distance array before BFS

C. Queue overflow not handled

D. Using 'int v : adj[u]' is invalid in C

Solution

1. Step 1: Check syntax of for loop in C

   Range-based for loops like 'for(int v : adj[u])' are not valid in C; this is C++ syntax.

2. Step 2: Identify correct iteration method in C

   In C, adjacency lists require explicit indexing or pointer iteration, not range-based loops.

3. Final Answer:

   Using 'int v : adj[u]' is invalid in C -> Option D

4. Quick Check:

   Range-based for loops = invalid in C [OK]

Hint: C uses indexed loops, not range-based for [OK]

Common Mistakes:

• Using C++ syntax in C code
• Ignoring queue overflow possibility
• Forgetting to initialize arrays

5. Given an unweighted graph with 6 nodes (0 to 5) and edges:

0-1, 0-2, 1-3, 3-4, 4-5

Write the shortest path from node 0 to node 5 using BFS. What is the path?

hard

A. [0, 1, 3, 4, 5]

B. [0, 2, 3, 4, 5]

C. [0, 1, 2, 3, 4, 5]

D. [0, 5]

Solution

1. Step 1: Run BFS from node 0 to find shortest distances

   Distances: 0(0), 1(1), 2(1), 3(2), 4(3), 5(4). BFS visits neighbors level-wise.

2. Step 2: Trace shortest path from 5 back to 0

   From 5 to 4, 4 to 3, 3 to 1 (via 1-3 edge; no 2-3 edge), 1 to 0.

3. Final Answer:

   [0, 1, 3, 4, 5] -> Option A

4. Quick Check:

   Shortest path = BFS parent chain [OK]

Hint: Trace BFS parents backward for shortest path [OK]

Common Mistakes:

• Choosing longer paths ignoring BFS order
• Assuming direct edge from 0 to 5
• Confusing BFS with DFS path