Non-recursive Topological Sorting Python
Algorithm:
The way topological sorting is solved is by processing a node after all of its children are processed. Each time a node is processed, it is pushed onto a stack in order to save the final result. This non-recursive solution builds on the same concept of DFS with a little tweak which can be understood above and in this article. However, unlike the recursive solution, which saves the order of the nodes in the stack after all the neighboring elements have been pushed to the program stack, this solution replaces the program stack with a working stack. If a node has a neighbor that has not been visited, the current node and the neighbor are pushed to the working stack to be processed until there are no more neighbors available to be visited.
After all the nodes have been visited, what remains is the final result which is found by printing the stack result in reverse.
Python3
#Python program to print topological sorting of a DAG from collections import defaultdict #Class to represent a graph class Graph: def __init__( self ,vertices): self .graph = defaultdict( list ) #dictionary containing adjacency List self .V = vertices #No. of vertices # function to add an edge to graph def addEdge( self ,u,v): self .graph[u].append(v) # neighbors generator given key def neighbor_gen( self ,v): for k in self .graph[v]: yield k # non recursive topological sort def nonRecursiveTopologicalSortUtil( self , v, visited,stack): # working stack contains key and the corresponding current generator working_stack = [(v, self .neighbor_gen(v))] while working_stack: # get last element from stack v, gen = working_stack.pop() visited[v] = True # run through neighbor generator until it's empty for next_neighbor in gen: if not visited[next_neighbor]: # not seen before? # remember current work working_stack.append((v,gen)) # restart with new neighbor working_stack.append((next_neighbor, self .neighbor_gen(next_neighbor))) break else : # no already-visited neighbor (or no more of them) stack.append(v) # The function to do Topological Sort. def nonRecursiveTopologicalSort( self ): # Mark all the vertices as not visited visited = [ False ] * self .V # result stack stack = [] # Call the helper function to store Topological # Sort starting from all vertices one by one for i in range ( self .V): if not (visited[i]): self .nonRecursiveTopologicalSortUtil(i, visited,stack) # Print contents of the stack in reverse stack.reverse() print (stack) g = Graph( 6 ) g.addEdge( 5 , 2 ); g.addEdge( 5 , 0 ); g.addEdge( 4 , 0 ); g.addEdge( 4 , 1 ); g.addEdge( 2 , 3 ); g.addEdge( 3 , 1 ); print ( "The following is a Topological Sort of the given graph" ) g.nonRecursiveTopologicalSort() |
The following is a Topological Sort of the given graph [5, 4, 2, 3, 1, 0]
Complexity Analysis:
- Time Complexity: O(V + E): The above algorithm is simply DFS with a working stack and a result stack. Unlike the recursive solution, recursion depth is not an issue here.
- Auxiliary space: O(V): The extra space is needed for the 2 stacks used.
Please refer complete article on Topological Sorting for more details.
Python Program for Topological Sorting
Topological sorting for Directed Acyclic Graph (DAG) is a linear ordering of vertices such that for every directed edge uv, vertex u comes before v in the ordering. Topological Sorting for a graph is not possible if the graph is not a DAG.