# Kahn's Algorithm vs DFS Approach: A Comparative Analysis

Directed acyclic graphs (DAGs) are functional data structures in many domains like scheduling, data processing workflows, and network analysis. An essential operation on DAGs is topological sorting, which arranges the graph nodes linearly to preserve edge directions. Topological sorting finds applications in instruction scheduling, ordering formula cell evaluation in spreadsheets, and plotting project timelines.

There are two well-known algorithms to implement topological sort on a DAG - Kahn's algorithm and depth-first search. Both produce a valid topological ordering but have slightly different properties and use cases. This article provides a comparative analysis of Kahn's algorithm versus the DFS approach for topological sorting. We discuss the steps involved in each algorithm, their time and space complexities, and the relative advantages and disadvantages of the two methods. The goal is to highlight when one approach might be preferred over the other depending on factors like implementation complexity, connectivity of the DAG, and the need for cycle detection. The discussion will provide helpful insights to engineers and researchers applying topological sorting to problems across scheduling, data processing, and network modelling domains.

## Kahn's Algorithm

Kahn's algorithm is named after Arthur Kahn, who described it in 1962. It works by repeatedly finding nodes with no incoming edges, removing them from the graph, and adding them to the linear ordering. This takes advantage of the critical property of a DAG that there must always be at least one node with in-degree 0. The algorithm repeats this process of finding in-degree 0 nodes, removing them, and appending them to the ordering until all nodes have been accounted for.

Steps The steps involved in Kahn's algorithm are:

1. Initialize a list L that will contain the nodes in topological order. It starts empty.
2. Initialize a set S to contain all nodes in the graph.
3. Find all nodes in S that have an in-degree of 0. These nodes have no incoming edges and can start the topological ordering.
4. Add the in-degree 0 nodes found in step 3 to L in arbitrary order and remove them from S.
5. The nodes added to L in the previous step now have outgoing edges to other nodes in S. Reduce the in-degree of all outgoing neighbours by 1 to account for the removal of edges.
6. Repeat steps 3-5, finding new in-degree 0 nodes, adding them to L and reducing in-degrees of neighbours until S is empty.
7. Once S is empty, L contains the nodes in topological order.

Correctness Proof The critical insight is that a non-empty DAG must always have at least one node with in-degree 0 until all nodes have been removed. This allows the nodes to be incrementally added to L by repeatedly finding these in-degree 0 nodes.

To prove correctness, we use mathematical induction.

Base case: At least one node will initially have in-degree 0 by defining a DAG. So, the algorithm works for the first node.

Inductive hypothesis: Assume the algorithm is correct for the first k nodes added to L.

Inductive step: When adding the (k+1)th node, reduce the in-degrees of existing nodes by 1 because removing edges cannot create a node with a negative in-degree. So, there must be at least one new node with in-degree 0 that can be added next.

Therefore, by mathematical induction, the algorithm will result in nodes added to L in topological order.

Time and Space Complexity The algorithm runs in O(V+E) time, where V is the number of nodes and E is the number of edges. Step 3 can be implemented in O(V) time by scanning all nodes. Step 4 takes O(E) time by checking the current node's neighbours. Steps 3-5 repeat V times total, once per node.

Space complexity is O(V) to store the list L and set S.

Output:

```Topological Sort: ['a', 'b', 'd', 'e', 'c']
```

Here is an explanation of the Python program to implement Kahn's algorithm for topological sorting:

The program first creates some helper data structures:

1. in_degree: A dictionary that keeps track of each node's in-degree (number of incoming edges).
2. Queue: A deque containing nodes of in-degree 0 ready to be added to the result.
3. Result: A list that will have the nodes in topological order.
• It then calculates the in-degree for each node by iterating over all edges:
• Each edge u → v increments the in_degree of v by 1.
• Next, it initializes the queue with all nodes having in-degree 0:
• If its in_degree is 0 for each node, add it to the queue.
• Now, the critical steps in Kahn's algorithm:

While the queue is not empty:

1. Pop a node from the queue's left side- this node is now added to the topological order in the result.
2. For each neighbour of the popped node, decrement its in_degree by 1.
3. If the neighbour's in_degree becomes 0, add it to the queue.

Finally, it checks if the number of nodes added to the result matches the total nodes. If not, there was a cycle. Otherwise, the result contains the topological sort order.

The example shows how to call the topological_sort method by passing a sample graph represented as an adjacency list. It prints out the final topological ordering or detects cycles.

## Depth First Search (DFS) Approach

Depth-first search (DFS) is an algorithmic technique that traverses a graph by exploring paths deeply towards unvisited vertices before backtracking and exploring other options. The critical characteristic of depth-first traversal is that it goes deeper into a particular path as far as it can before retreating and trying different paths. When applied to the topological ordering of directed acyclic graphs (DAGs), DFS traversal can efficiently compute a valid topological sorting order by tracking the finish times of vertices and printing them in reverse. Specifically, DFS explores the graph starting from one vertex, recursing fully into one outgoing path before retracting and trying a different branch. The last vertex finished in any path is guaranteed to have no further neighbours unexplored. An appropriately ordered topological sorting emerges directly by recording finish times in a stack and popping vertices in reverse order. The built-in mechanism for traversing a graph deeply before broadening the search makes DFS a simple and elegant choice for topological order computation. With the time complexity of O(V+E) matching other methods, DFS is an optimal algorithm for topological sort in practical applications. Its simplicity of implementation and ability to detect cycles during execution make it a versatile option across domains relying on the correct ordering of directed acyclic graph elements.

### Algorithm

The high-level steps are:

1. Do a DFS traversal of the given DAG
2. Store the completion times of vertices in a stack.
3. Pop elements from the stack to print topological order.

The DFS traversal has additional bookkeeping:

1. Mark the visit status of each vertex (unvisited, visited, visiting)
2. On seeing a vertex, recur for all its unvisited neighbours
3. After recursive calls, mark the vertex as saw and push it into a stack

The recursive calls continue until we find a vertex with no unvisited neighbours.

Stacking Vertices The critical insight is that the vertex on top of the recursion stack or the last vertex printed during DFS is always a leaf vertex (or local sink). Hence, we print a topologically sorted order by printing vertices in the reverse order of completion.

For example, consider the graph:

A → B → C → D

The DFS may visit vertices in order A B D C, But stack printed order will be: C D B A

which is topologically sorted.

Handling Cycles can also be detected easily in DFS if we encounter a visited vertex during traversal. We can print a message accordingly.

Complexity: Time complexity is O(V+E) to visit all vertices and edges. If the graph is a linear chain, space complexity is O(V) for the stack in the worst case.

Output:

```Topological Sort: ['a', 'b', 'd', 'e', 'c']
```

Explanation

1. Define a dfs(node) recursive function that will do the depth-first traversal starting from a node.
2. Inside dfs():
1. Mark the current node as visited
2. Recursively call dfs on each unvisited neighbouring node
3. After recursively traversing neighbors, append the current node to the global result list
3. Initialize a visited set to track visited nodes
4. Initialize result list to store nodes of final topological order
5. Call dfs traversal starting from each unvisited node in the graph
6. After dfs calls from all nodes, reverse the result
7. Return reversed result

How does it work:

• It starts DFS from each unvisited node as a starting point
• Each node gets appended to the result only after its neighbors have been traversed
• So, the result list contains nodes in reverse order of finish times
• By reversing the result, we get the topological ordering

The key insight is that DFS explores paths till their completion before retracting and exploring other ways. So, the last node in any path gets added to the result after its dependencies.

Finally, we print out the returned topological order if no cycle is detected.

### Difference Between Kahn's Algo and DFS

Order of Visiting Vertices

Kahn's:

• Explicitly chooses the next vertex based on minimum in-degree heuristic
• Can pick vertices in any arbitrary order if multiple nodes have in-degree 0 (set/queue implementation)
• Visits vertices layer-by-layer from ones with fewer dependencies to more dependencies

DFS:

• Follows implicit order of visitation based on recursion tree
• Always visit neighbours of the current node as deep as possible before coming back
• This can lead to different orders based on the starting vertex
• Visits vertices more linearly following edges vs Kahn's layer-by-layer approach

### Handling Disconnected Graphs

Kahn's:

• Works correctly even if the graph is not connected
• In-degree calculations are valid independently per component
• Results in correct topological sort per component

DFS:

• Must be provided a starting vertex in each piece to fully traverse
• Fails to visit vertices not reachable from the starting node
• Cannot topologically sort disconnected graphs as is

### Complexity Analysis

Asymptotic complexity:

• Both are Θ(V+E) for adjacency list representation
• O(V+E) or simply linear in terms of vertices and edges

Constants factor difference:

• DFS requires more function calls due to recursion
• Kahn's more straightforward iterative in-degree update might be faster

Actual performance depends on:

• Connectivity and structure of graphs
• Input size thresholds where overheads dominate

So, for vast and sparse graphs, Kahn's would likely outperform DFS by a slight constant factor difference.

### Ease of Implementation

Kahn's algorithm:

• Conceptually simple, direct in-degree based processing
• Iterative algorithm, no recursion stack

DFS:

• More complex with recursion, call stack and backtracking
• Harder to debug compared to iterative Kahn's approach
• Simple recursion coding errors can break logic

So, Kahn's algorithm is generally more straightforward to code up correctly.

Basis Kahn's Algorithm DFS Approach
Order of Visiting Vertices Chooses vertices explicitly based on in-degree Implicit order based on recursion tree
Handling Disconnected Graphs Works correctly irrespective of connectivity Requires a connected graph
Time Complexity O(V+E) O(V+E)
Space Complexity O(V+E) O(V)
Implementation Complexity Iterative logic, no recursion stack Recursive calls require a stack
Cycle Detection Fails if cycle present Can detect cycle via visited nodes
Choice of Starting Node Not impacted by starting vertex Different orders based on the starting node
Suitable Graph Density Performs well on sparse graphs Dense graphs increase recursion overheads
Correctness Guarantee Directly constructs topological order Relies on post-order of DFS traversal
Use Cases Preferred when cycle detection is not needed, or the graph is disconnected Best when requiring cycle detection or connected components