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

Time Complexity: Topological Sort Using Kahn's Algorithm BFS

O(n + 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.

fn kahn_topological_sort(graph: &Vec>, indegree: &mut Vec) -> Vec {
    let mut queue = std::collections::VecDeque::new();
    for i in 0..graph.len() {
        if indegree[i] == 0 {
            queue.push_back(i);
        }
    }
    let mut topo_order = Vec::new();
    while let Some(node) = queue.pop_front() {
        topo_order.push(node);
        for &neighbor in &graph[node] {
            indegree[neighbor] -= 1;
            if indegree[neighbor] == 0 {
                queue.push_back(neighbor);
            }
        }
    }
    topo_order
}
    

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

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Visiting each node and its edges once.
• How many times: Each node is enqueued and dequeued once; each edge is checked once.

How Execution Grows With Input

As the number of nodes (n) and edges (e) grow, the algorithm processes each node and edge once.

Input Size (n, e)	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 work grows roughly in direct proportion to the sum of nodes and edges.

Final Time Complexity

Time Complexity: O(n + e)

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

Common Mistake

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

[OK] Correct: Although there are loops inside loops, each edge and node is processed only once, so the total work is linear, not quadratic.

Interview Connect

Understanding this time complexity helps you explain how efficient graph algorithms work and shows you can analyze BFS-based approaches clearly.

Self-Check

"What if the graph is 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 a topological ordering of a Directed Acyclic Graph (DAG)

B. To find the shortest path between two nodes

C. To detect cycles in an undirected graph

D. To calculate the minimum spanning tree

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 uv, vertex u comes before v in the ordering.

2. Step 2: Compare with other graph algorithms

   Shortest path algorithms find paths, cycle detection checks for loops, and minimum spanning tree algorithms work on undirected graphs. Kahn's Algorithm specifically produces a topological order.

3. Final Answer:

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

4. Quick Check:

   Topological sort = Kahn's Algorithm purpose [OK]

Hint: Kahn's Algorithm always orders DAG nodes topologically [OK]

Common Mistakes:

• Confusing topological sort with shortest path
• Thinking it detects cycles in undirected graphs
• Mixing it with minimum spanning tree algorithms

2. Which Rust data structure is best suited to keep track of nodes with zero incoming edges in Kahn's Algorithm?

easy

A. HashMap

B. VecDeque (double-ended queue)

C. BinaryHeap

D. LinkedList

Solution

1. Step 1: Identify the need for queue behavior

   Kahn's Algorithm processes nodes with zero incoming edges in FIFO order, so a queue is needed to efficiently pop from front and push at back.

2. Step 2: Choose the Rust data structure

   VecDeque provides efficient push and pop operations at both ends, making it ideal for queue operations. HashMap is for key-value storage, BinaryHeap is a priority queue, and LinkedList is less efficient in Rust.

3. Final Answer:

   VecDeque (double-ended queue) -> Option B

4. Quick Check:

   Queue for zero in-degree nodes = VecDeque [OK]

Hint: Use VecDeque for queue operations in Rust [OK]

Common Mistakes:

• Using HashMap instead of a queue
• Choosing BinaryHeap which is a priority queue
• Using LinkedList which is inefficient in Rust

3. Given the following Rust code snippet implementing Kahn's Algorithm, what will be the printed topological order?

let edges = vec![(0, 1), (0, 2), (1, 3), (2, 3)];
let n = 4;
// Assume graph and in_degree are built correctly
// After running Kahn's Algorithm, the order vector is printed
println!("{:?}", order);

medium

A. [0, 1, 2, 3]

B. [3, 1, 2, 0]

C. [0, 2, 1, 3]

D. [1, 0, 2, 3]

Solution

1. Step 1: Analyze the graph edges and in-degree

   Edges: 0->1, 0->2, 1->3, 2->3. Node 0 has in-degree 0, nodes 1 and 2 have in-degree 1, node 3 has in-degree 2.

2. Step 2: Perform Kahn's Algorithm BFS

   Start with node 0 (in-degree 0). Remove it, reduce in-degree of 1 and 2 to 0. Add 1 and 2 to queue. Next, remove 1, then 2, then 3. Order is [0, 1, 2, 3]. However, since nodes 1 and 2 become zero in-degree simultaneously, the order of processing them can vary. If we process 2 before 1, the order is [0, 2, 1, 3], which is also valid.

3. Final Answer:

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

4. Quick Check:

   Topological order respects edges = [0, 2, 1, 3] [OK]

Hint: Start with zero in-degree nodes and process neighbors [OK]

Common Mistakes:

• Reversing order of nodes processed
• Ignoring in-degree updates
• Assuming multiple valid orders without checking edges

4. Identify the bug in this Rust snippet of Kahn's Algorithm:

for &node in &graph[node] {
    in_degree[node] -= 1;
    if in_degree[node] == 0 {
        queue.push_back(node);
    }
}

medium

A. Missing initialization of in_degree array

B. Should use 'queue.push_front' instead of 'push_back'

C. Queue should be a stack for correct order

D. Using 'node' as loop variable shadows outer 'node', causing wrong indexing

Solution

1. Step 1: Understand variable shadowing in the loop

   The loop uses 'node' as the loop variable, which shadows the outer 'node' variable used to index graph. This causes confusion and incorrect indexing.

2. Step 2: Correct the variable naming

   Use a different variable name like 'neighbor' in the loop to avoid shadowing and correctly access neighbors.

3. Final Answer:

   Using 'node' as loop variable shadows outer 'node', causing wrong indexing -> Option D

4. Quick Check:

   Variable shadowing causes bugs = Using 'node' as loop variable shadows outer 'node', causing wrong indexing [OK]

Hint: Avoid reusing variable names in nested loops [OK]

Common Mistakes:

• Ignoring variable shadowing
• Confusing queue with stack usage
• Assuming in_degree initialization is the bug

5. You have a graph with edges: [(5, 2), (5, 0), (4, 0), (4, 1), (2, 3), (3, 1)]. Using Kahn's Algorithm, which of the following is a valid topological order?

hard

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

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

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

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

Solution

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

   Nodes: 0,1,2,3,4,5 In-degree: 0(2), 1(2), 2(1), 3(1), 4(0), 5(0)

2. Step 2: Perform Kahn's Algorithm steps

   Start with nodes 4 and 5 (in-degree 0). Remove 5: reduce in-degree of 2 and 0. Remove 4: reduce in-degree of 0 and 1. Then remove 2, 3, 1, 0 in order. One valid order is [5, 4, 2, 3, 1, 0].

3. Final Answer:

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

4. Quick Check:

   Valid topological order respects edges = [5, 4, 2, 3, 1, 0] [OK]

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

Common Mistakes:

• Choosing orders that violate edge directions
• Ignoring initial zero in-degree nodes
• Mixing node order without updating in-degree