Topological Sort Using Kahn's Algorithm BFS in DSA C++ - Time & Space Complexity

Time Complexity: Topological Sort Using Kahn's Algorithm BFS

O(V + E)

Understanding Time Complexity

We want to understand how the time needed to perform topological sort using Kahn's Algorithm grows as the graph size increases.

Specifically, how the number of nodes and edges affects the work done.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

void kahnTopologicalSort(int V, vector<int> adj[]) {
    vector<int> indegree(V, 0);
    for (int i = 0; i < V; i++) {
        for (int node : adj[i]) {
            indegree[node]++;
        }
    }
    queue<int> q;
    for (int i = 0; i < V; i++) {
        if (indegree[i] == 0) q.push(i);
    }
    while (!q.empty()) {
        int u = q.front(); q.pop();
        // process u
        for (int v : adj[u]) {
            indegree[v]--;
            if (indegree[v] == 0) q.push(v);
        }
    }
}
    

This code performs a topological sort on a directed graph using Kahn's BFS algorithm.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Traversing all edges in the graph.
• How many times: Each edge is visited exactly once during indegree calculation and once during BFS processing.

How Execution Grows With Input

As the number of nodes (V) and edges (E) grow, the algorithm visits each node and edge a fixed number of times.

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

Pattern observation: The operations grow roughly in proportion to the sum of nodes and edges.

Final Time Complexity

Time Complexity: O(V + E)

This means the time needed grows linearly with the number of nodes plus the number of edges in the graph.

Common Mistake

[X] Wrong: "The algorithm takes O(V²) time because it uses nested loops."

[OK] Correct: The inner loops do not run V times for each node; they run once per edge. So total work depends on edges, not V squared.

Interview Connect

Understanding this time complexity helps you explain why Kahn's Algorithm is efficient for dependency resolution and scheduling problems.

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 is the main purpose of Kahn's Algorithm in graph theory?

easy

A. To find the shortest path between two nodes

B. To calculate the minimum spanning tree

C. To detect cycles in an undirected graph

D. To find a topological ordering of a Directed Acyclic Graph (DAG)

Solution

1. Step 1: Understand Kahn's Algorithm goal

   Kahn's Algorithm is designed to produce a linear ordering of vertices in a Directed Acyclic Graph (DAG) such that for every directed edge u -> v, u comes before v in the ordering.

2. Step 2: Compare with other graph algorithms

   Other options describe different algorithms: shortest path (Dijkstra's or BFS), cycle detection in undirected graphs (DFS), and minimum spanning tree (Kruskal's or Prim's) are unrelated to Kahn's Algorithm.

3. Final Answer:

   To find a topological ordering of a Directed Acyclic Graph (DAG) -> Option D

4. Quick Check:

   Topological sort = Kahn's Algorithm purpose [OK]

Hint: Kahn's Algorithm always finds topological order in DAGs [OK]

Common Mistakes:

• Confusing topological sort with shortest path
• Thinking it works on undirected graphs
• Assuming it detects cycles directly

2. Which of the following C++ STL containers is best suited to implement the queue used in Kahn's Algorithm?

easy

A. std::queue

B. std::set

C. std::vector

D. std::stack

Solution

1. Step 1: Identify the data structure needed

   Kahn's Algorithm uses a queue to process nodes with zero incoming edges in FIFO order.

2. Step 2: Match with C++ STL containers

   std::queue provides FIFO behavior, suitable for this purpose. std::stack is LIFO, std::vector is dynamic array without FIFO, std::set is ordered but not FIFO.

3. Final Answer:

   std::queue -> Option A

4. Quick Check:

   Queue = std::queue [OK]

Hint: Use std::queue for FIFO processing in Kahn's Algorithm [OK]

Common Mistakes:

• Using std::stack instead of std::queue
• Using std::vector without queue operations
• Using std::set which is ordered but not FIFO

3. What is the output of the following code snippet implementing Kahn's Algorithm on the graph with edges: 5->0, 5->2, 4->0, 4->1, 2->3, 3->1?

std::vector graph = {{}, {}, {}, {}, {}, {}};
// Edges added as graph[5].push_back(0), etc.
// After running Kahn's Algorithm, which topological order is printed?
// Options are sequences of node numbers.

medium

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

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

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

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

Solution

1. Step 1: Build indegree and initialize queue

   Nodes 4 and 5 have zero indegree, so queue starts with [4,5].

2. Step 2: Process nodes in queue order

   Process 4: remove edges 4->0, 4->1; indegree of 0 and 1 decrease. Process 5: remove edges 5->0, 5->2; indegree of 0 and 2 decrease. When indegree of 0 and 2 become zero, add to queue. Continue processing 0, 2, 3, 1 in order.

3. Final Answer:

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

4. Quick Check:

   Topological order = [4,5,0,2,3,1] [OK]

Hint: Start with nodes having zero indegree in queue [OK]

Common Mistakes:

• Starting queue with wrong nodes
• Not updating indegree correctly
• Mixing order of nodes with zero indegree

4. What is missing from this Kahn's Algorithm implementation:

std::vector<int> indegree(V, 0);
for (int u = 0; u < V; u++) {
  for (int v : graph[u]) {
    indegree[v]++;
  }
}
std::queue<int> q;
for (int i = 0; i < V; i++) {
  if (indegree[i] == 0) q.push(i);
}
while (!q.empty()) {
  int u = q.front(); q.pop();
  for (int v : graph[u]) {
    indegree[v]--;
    if (indegree[v] == 0) q.push(v);
  }
  // Missing code here
}

medium

A. Not decrementing indegree[v] inside the loop

B. Not printing or storing the topological order nodes

C. Not checking if the graph has cycles before running

D. Not pushing nodes with zero indegree into the queue initially

Solution

1. Step 1: Analyze the loop behavior

   The code correctly calculates indegree and pushes zero indegree nodes into the queue. It decrements indegree and pushes new zero indegree nodes inside the loop.

2. Step 2: Identify missing action

   The missing code is to store the popped node u into a topological order vector, e.g., topo.push_back(u); after q.pop();. Without it, the algorithm processes correctly but does not output the order.

3. Final Answer:

   Not printing or storing the topological order nodes -> Option B

4. Quick Check:

   Missing topo.push_back(u) [OK]

Hint: Always record nodes when popping from queue [OK]

Common Mistakes:

• Forgetting to store or print topological order
• Incorrect indegree decrement logic
• Not initializing queue with zero indegree nodes

5. Given a Directed Acyclic Graph (DAG) with 6 nodes and edges: 0->1, 0->2, 1->3, 2->3, 3->4, 4->5, how can Kahn's Algorithm be modified to detect if the graph contains a cycle?

hard

A. Count processed nodes; if count < total nodes, a cycle exists

B. Check if queue becomes empty

C. Use a visited array to mark nodes and detect back edges

D. Run DFS instead of BFS to find cycles

Solution

1. Step 1: Understand Kahn's Algorithm processing

   Kahn's Algorithm processes nodes with zero indegree and removes edges. If a cycle exists, some nodes never reach zero indegree and remain unprocessed.

2. Step 2: Detect cycle by counting processed nodes

   If the number of processed nodes is less than total nodes, it means some nodes are stuck due to cycles. This is a standard cycle detection method using Kahn's Algorithm.

3. Final Answer:

   Count processed nodes; if count < total nodes, a cycle exists -> Option A

4. Quick Check:

   Processed nodes count < total nodes = cycle [OK]

Hint: Compare processed nodes count with total nodes [OK]

Common Mistakes:

• Assuming Kahn's Algorithm alone detects cycles without counting
• Confusing BFS with DFS cycle detection methods
• Not tracking processed nodes count