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

Topological Sort Using Kahn's Algorithm BFS

📖 Scenario: Imagine 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 so that no task is done before its dependencies.

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

📋 What You'll Learn

Create a graph using adjacency list representation with exact tasks and dependencies

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

Implement Kahn's Algorithm using a queue to process tasks with zero in-degree

Print the topological order of tasks separated by spaces

💡 Why This Matters

🌍 Real World

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

💼 Career

Understanding topological sort and graph algorithms is important for software engineers working on compilers, task schedulers, and dependency management.

1

Create the graph with tasks and dependencies

Create a dictionary called graph with keys as integers 0 to 5 representing tasks, and values as lists of integers representing dependent tasks. Use these exact edges: 5 -> 2, 5 -> 0, 4 -> 0, 4 -> 1, 2 -> 3, 3 -> 1.

DSA C#

# Create the graph dictionary with the given edges
# Your code here

Hint

Use a dictionary with keys 0 to 5 and empty lists. Then add edges using graph[key].Add(value).

2

Create the in-degree array for tasks

Create an integer array called inDegree of size 6 initialized with zeros. Then, use a foreach loop to iterate over graph and increase the in-degree for each dependent task.

DSA C#

using System.Collections.Generic;

Dictionary> graph = new Dictionary>
{
    {0, new List()},
    {1, new List()},
    {2, new List()},
    {3, new List()},
    {4, new List()},
    {5, new List()}
};
graph[5].Add(2);
graph[5].Add(0);
graph[4].Add(0);
graph[4].Add(1);
graph[2].Add(3);
graph[3].Add(1);

// Create inDegree array and calculate in-degree for each task
// Your code here

Hint

Initialize inDegree with zeros. Then count how many times each task appears as a dependent in the graph.

3

Implement Kahn's Algorithm to find topological order

Create a queue called queue and enqueue all tasks with zero in-degree. Then, use a while loop to dequeue tasks, add them to a list called topoOrder, and decrease the in-degree of their dependent tasks. Enqueue dependent tasks when their in-degree becomes zero.

DSA C#

using System.Collections.Generic;

Dictionary> graph = new Dictionary>
{
    {0, new List()},
    {1, new List()},
    {2, new List()},
    {3, new List()},
    {4, new List()},
    {5, new List()}
};
graph[5].Add(2);
graph[5].Add(0);
graph[4].Add(0);
graph[4].Add(1);
graph[2].Add(3);
graph[3].Add(1);

int[] inDegree = new int[6];
foreach (var edges in graph.Values)
{
    foreach (int node in edges)
    {
        inDegree[node]++;
    }
}

// Implement Kahn's Algorithm using a queue and list topoOrder
// Your code here

Hint

Start with tasks that have no dependencies. Remove them and update dependent tasks' in-degree. Repeat until all tasks are processed.

4

Print the topological order of tasks

Use Console.WriteLine to print the tasks in topoOrder separated by spaces on one line.

DSA C#

using System;
using System.Collections.Generic;

Dictionary> graph = new Dictionary>
{
    {0, new List()},
    {1, new List()},
    {2, new List()},
    {3, new List()},
    {4, new List()},
    {5, new List()}
};
graph[5].Add(2);
graph[5].Add(0);
graph[4].Add(0);
graph[4].Add(1);
graph[2].Add(3);
graph[3].Add(1);

int[] inDegree = new int[6];
foreach (var edges in graph.Values)
{
    foreach (int node in edges)
    {
        inDegree[node]++;
    }
}

Queue queue = new Queue();
for (int i = 0; i  topoOrder = new List();
while (queue.Count > 0)
{
    int current = queue.Dequeue();
    topoOrder.Add(current);
    foreach (int neighbor in graph[current])
    {
        inDegree[neighbor]--;
        if (inDegree[neighbor] == 0)
        {
            queue.Enqueue(neighbor);
        }
    }
}

// Print the topological order separated by spaces
// Your code here

Hint

Use Console.WriteLine(string.Join(" ", topoOrder)) to print all tasks in order separated by spaces.

Practice

1. What is the main purpose of Kahn's Algorithm in graph theory?

easy

A. To calculate the minimum spanning tree

B. To detect cycles in an undirected graph

C. To find the shortest path between two nodes

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 graph problems: cycle detection, shortest path, and minimum spanning tree, which are not the purpose of 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 order in DAGs [OK]

Common Mistakes:

• Confusing topological sort with cycle detection
• Thinking it finds shortest paths
• Mixing with minimum spanning tree algorithms

2. Which C# data structure is best suited to store nodes with zero incoming edges during Kahn's Algorithm?

easy

A. Queue

B. Stack

C. Dictionary

D. HashSet

Solution

1. Step 1: Identify the role of zero in-degree nodes

   Kahn's Algorithm processes nodes with zero incoming edges in the order they are discovered, which requires a First-In-First-Out (FIFO) structure.

2. Step 2: Match data structure to FIFO behavior

   A Queue provides FIFO behavior, making it ideal to store and process zero in-degree nodes in the correct order.

3. Final Answer:

   Queue -> Option A

4. Quick Check:

   Zero in-degree nodes use FIFO queue [OK]

Hint: Use queue for BFS order in Kahn's Algorithm [OK]

Common Mistakes:

• Using stack which is LIFO, not suitable here
• Choosing dictionary which stores key-value pairs
• Using hashset which has no order

3. What is the output of the following C# code snippet implementing Kahn's Algorithm on this graph?

var graph = new Dictionary<int, List<int>> {
  {1, new List<int> {2, 3}},
  {2, new List<int> {4}},
  {3, new List<int> {4}},
  {4, new List<int> ()}
};
var result = TopologicalSort(graph);
Console.WriteLine(string.Join(", ", result));

List<int> TopologicalSort(Dictionary<int, List<int>> graph) {
  var inDegree = new Dictionary<int, int>();
  foreach (var node in graph.Keys) inDegree[node] = 0;
  foreach (var edges in graph.Values)
    foreach (var v in edges) inDegree[v]++;
  var queue = new Queue<int>(inDegree.Where(kv => kv.Value == 0).Select(kv => kv.Key));
  var topoOrder = new List<int>();
  while (queue.Count > 0) {
    var u = queue.Dequeue();
    topoOrder.Add(u);
    foreach (var v in graph[u]) {
      inDegree[v]--;
      if (inDegree[v] == 0) queue.Enqueue(v);
    }
  }
  return topoOrder;
}

medium

A. [4, 2, 3, 1]

B. [1, 2, 3, 4]

C. [1, 3, 2, 4]

D. [2, 3, 1, 4]

Solution

1. Step 1: Calculate in-degree for each node

   Node 1: 0, Node 2: 1 (from 1), Node 3: 1 (from 1), Node 4: 2 (from 2 and 3).

2. Step 2: Process nodes in queue order

   Start with node 1 (in-degree 0). Remove it, reduce in-degree of 2 and 3 to 0, enqueue both. Then dequeue 2, reduce in-degree of 4 to 1. Dequeue 3, reduce in-degree of 4 to 0, enqueue 4. Finally dequeue 4.

3. Final Answer:

   [1, 2, 3, 4] -> Option B

4. Quick Check:

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

Hint: Track in-degree and queue order carefully [OK]

Common Mistakes:

• Ignoring in-degree updates after dequeue
• Mixing order of nodes with same in-degree
• Starting with wrong initial nodes

4. Identify the bug in this Kahn's Algorithm C# code snippet:

var inDegree = new Dictionary<int, int>();
foreach (var node in graph.Keys) inDegree[node] = 0;
foreach (var edges in graph.Values)
  foreach (var v in edges) inDegree[v] = 0; // Bug here
var queue = new Queue<int>(inDegree.Where(kv => kv.Value == 0).Select(kv => kv.Key));

medium

A. Queue should be a stack for correct order

B. The first loop should initialize inDegree with -1

C. The second loop resets in-degree to zero instead of incrementing

D. The graph.Keys should be iterated twice

Solution

1. Step 1: Analyze in-degree calculation

   The second loop incorrectly sets inDegree[v] = 0 for each adjacent node, overwriting the count instead of incrementing it.

2. Step 2: Correct in-degree update

   It should increment inDegree[v] by 1 for each incoming edge to count properly, i.e., inDegree[v]++.

3. Final Answer:

   The second loop resets in-degree to zero instead of incrementing -> Option C

4. Quick Check:

   In-degree must be incremented, not reset [OK]

Hint: Increment in-degree counts, don't reset them [OK]

Common Mistakes:

• Setting in-degree to zero inside the counting loop
• Using stack instead of queue
• Misinitializing in-degree dictionary

5. Given a graph with edges: 5->2, 5->0, 4->0, 4->1, 2->3, 3->1, which of the following is a valid topological order using Kahn's Algorithm?

hard

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

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

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

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

Solution

1. Step 1: Calculate in-degree for each node

   Nodes: 0(in-degree 2 from 4,5), 1(in-degree 2 from 3,4), 2(in-degree 1 from 5), 3(in-degree 1 from 2), 4(in-degree 0), 5(in-degree 0).

2. Step 2: Process nodes with zero in-degree first

   Start with 5 and 4. Removing 5 reduces in-degree of 2 to 0 and 0 to 1; removing 4 reduces in-degree of 0 to 0 and 1 to 1. Then process 2 and 0 (in some order), followed by 3, then 1.

3. Final Answer:

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

4. Quick Check:

   Valid topological order respects edges [OK]

Hint: Start with zero in-degree nodes, remove edges stepwise [OK]

Common Mistakes:

• Placing nodes before their dependencies
• Ignoring multiple valid orders
• Starting with nodes that have incoming edges