Topological Sort Using Kahn's Algorithm BFS in DSA C++ - Build from Scratch

Topological Sort Using Kahn's Algorithm BFS

📖 Scenario: You are managing tasks in a project where some tasks must be done before others. You want to find an order to do all tasks without breaking any rules.

🎯 Goal: Build a program that uses Kahn's Algorithm with BFS to find a valid order of tasks (topological sort) from given dependencies.

📋 What You'll Learn

Create an adjacency list to represent the directed graph of tasks

Create an array to store the in-degree (number of incoming edges) of each task

Use a queue to process tasks with zero in-degree

Implement Kahn's Algorithm to find the topological order

Print the topological order of tasks

💡 Why This Matters

🌍 Real World

Topological sorting is used in project scheduling, build systems, and resolving dependencies in software packages.

💼 Career

Understanding topological sort helps in roles like software development, project management, and systems engineering where task ordering and dependency resolution are critical.

1

Create the graph adjacency list

Create a vector of vectors called graph with size 6 to represent the directed edges between tasks. Add these edges exactly: from 5 to 2, from 5 to 0, from 4 to 0, from 4 to 1, from 2 to 3, and from 3 to 1.

DSA C++

std::vector> graph(6);
// Your code here

Hint

Use graph[from].push_back(to); to add edges.

2

Create the in-degree array

Create a vector of integers called in_degree with size 6 and initialize all values to 0. Then, use a for loop with variable u to iterate over graph and inside it, use a for loop with variable v to increment in_degree[v] by 1 for each edge.

DSA C++

std::vector in_degree(6, 0);
// Your code here

Hint

Count how many edges come into each node.

3

Implement Kahn's Algorithm BFS

Create a queue of integers called q. Use a for loop with variable i from 0 to 5 to push all nodes with in_degree[i] == 0 into q. Create a vector of integers called topo_order to store the topological order. Use a while loop to process nodes from q: pop the front node into u, add u to topo_order, then for each neighbor v in graph[u], decrement in_degree[v] by 1 and if in_degree[v] becomes 0, push v into q.

DSA C++

// Your code here

Hint

Use a queue to process nodes with zero in-degree and update neighbors.

4

Print the topological order

Use a for loop with variable i to iterate over topo_order and print each element followed by a space. Then print a newline.

DSA C++

// Your code here

Hint

Print all tasks in the order stored in topo_order.

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