Topological Sorting in Python

Given a Directed Acyclic Graph (DAG), the task is to find a linear order of its vertices such that for every directed edge u -> v, vertex u appears before v in the order. Topological Sorting is a technique used to arrange vertices of a DAG in a sequence that respects all dependencies. It ensures that no vertex appears before any of its prerequisites.

For Example:

Input Graph:

👁 topologicalSorting

Output: 5 4 2 3 1 0
Explanation: Vertex 5 and 4 have no incoming edges, so they appear first. Each vertex appears only after all vertices pointing to it have been placed earlier in the order.

Using Kahn’s Algorithm (BFS-Based)

It works by repeatedly removing nodes with zero in-degree (no incoming edges) and adding them to the topological order until all nodes are processed. Here in this code, we use a queue to store vertices with zero in-degree and gradually build the order.

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

Explanation:

• Nodes with zero in-degree are added to the queue first (4 and 5).
• As each node is processed, its neighbors’ in-degrees are decreased.
• The order [4, 5, 2, 0, 3, 1] ensures every node appears after its dependencies.

Using Recursive DFS-Based Approach

This approach uses Depth-First Search (DFS) and recursion to find the topological order of a Directed Acyclic Graph (DAG). It explores all dependencies first and then adds the node to a stack, ensuring the correct order. The final sequence is obtained by reversing the stack.

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

Explanation:

• dfsSort() explores all dependencies of a node recursively before adding it to the stack.
• Nodes are inserted at the front of the stack only after all their children are processed.
• The final stack order [5, 4, 2, 3, 1, 0] ensures dependencies come before dependents.

Using Iterative DFS-Based Approach

This method eliminates recursion and uses an explicit stack to simulate DFS traversal. It employs generators for efficient neighbor iteration and manually manages backtracking. This approach is useful for handling large graphs without hitting recursion limits.

Topological Sort using Iterative DFS:
[5, 4, 2, 3, 1, 0]

Explanation:

• working_stack simulates recursion manually to avoid recursion depth issues.
• Each node’s neighbors are visited using iter(self.graph[v]) and pushed to the stack if unvisited.
• Nodes are inserted into the final stack after all neighbors are processed, maintaining dependency order.

Please refer complete article on Topological Sorting for more details.