Open in App
Not now

# Topological Sorting

• Difficulty Level : Medium
• Last Updated : 08 Mar, 2023

Topological sorting for Directed Acyclic Graph (DAG) is a linear ordering of vertices such that for every directed edge u v, vertex u comes before v in the ordering.

Note: Topological Sorting for a graph is not possible if the graph is not a DAG.

For example, a topological sorting of the following graph is “5 4 2 3 1 0”. There can be more than one topological sorting for a graph. Another topological sorting of the following graph is “4 5 2 3 1 0”. The first vertex in topological sorting is always a vertex with an in-degree of 0 (a vertex with no incoming edges).

Recommended Practice

## Topological Sortingvs Depth First Traversal (DFS):

In DFS, we print a vertex and then recursively call DFS for its adjacent vertices. In topological sorting, we need to print a vertex before its adjacent vertices.

For example, in the given graph, the vertex ‘5’ should be printed before vertex ‘0’, but unlike DFS, the vertex ‘4’ should also be printed before vertex ‘0’. So Topological sorting is different from DFS. For example, a DFS of the shown graph is “5 2 3 1 0 4”, but it is not a topological sorting.

## Algorithm for Topological Sorting:

Prerequisite: DFS

We can modify DFS to find the Topological Sorting of a graph. In DFS

• We start from a vertex, we first print it, and then
• Recursively call DFS for its adjacent vertices.

In topological sorting,

• We use a temporary stack.
• We don’t print the vertex immediately,
• we first recursively call topological sorting for all its adjacent vertices, then push it to a stack.
• Finally, print the contents of the stack.

Note: A vertex is pushed to stack only when all of its adjacent vertices (and their adjacent vertices and so on) are already in the stack

Approach:

• Create a stack to store the nodes.
• Initialize visited array of size N to keep the record of visited nodes.
• Run a loop from 0 till N
• if the node is not marked True in visited array
• Call the recursive function for topological sort and perform the following steps.
• Mark the current node as True in the visited array.
• Run a loop on all the nodes which has a directed edge to the current node
• if the node is not marked True in the visited array:
• Recursively call the topological sort function on the node
• Push the current node in the stack.
• Print all the elements in the stack.

Below image is an illustration of the above approach:

Please see the code for Depth First Traversal for a disconnected Graph and note the differences between the second code given there and the below code.

Below is the implementation of the above approach:

## C++

 `// A C++ program to print topological` `// sorting of a DAG` `#include ` `using` `namespace` `std;`   `// Class to represent a graph` `class` `Graph {` `    ``// No. of vertices'` `    ``int` `V;`   `    ``// Pointer to an array containing adjacency listsList` `    ``list<``int``>* adj;`   `    ``// A function used by topologicalSort` `    ``void` `topologicalSortUtil(``int` `v, ``bool` `visited[],` `                             ``stack<``int``>& Stack);`   `public``:` `    ``// Constructor` `    ``Graph(``int` `V);`   `    ``// function to add an edge to graph` `    ``void` `addEdge(``int` `v, ``int` `w);`   `    ``// prints a Topological Sort of` `    ``// the complete graph` `    ``void` `topologicalSort();` `};`   `Graph::Graph(``int` `V)` `{` `    ``this``->V = V;` `    ``adj = ``new` `list<``int``>[V];` `}`   `void` `Graph::addEdge(``int` `v, ``int` `w)` `{` `    ``// Add w to vâ€™s list.` `    ``adj[v].push_back(w);` `}`   `// A recursive function used by topologicalSort` `void` `Graph::topologicalSortUtil(``int` `v, ``bool` `visited[],` `                                ``stack<``int``>& Stack)` `{` `    ``// Mark the current node as visited.` `    ``visited[v] = ``true``;`   `    ``// Recur for all the vertices` `    ``// adjacent to this vertex` `    ``list<``int``>::iterator i;` `    ``for` `(i = adj[v].begin(); i != adj[v].end(); ++i)` `        ``if` `(!visited[*i])` `            ``topologicalSortUtil(*i, visited, Stack);`   `    ``// Push current vertex to stack` `    ``// which stores result` `    ``Stack.push(v);` `}`   `// The function to do Topological Sort.` `// It uses recursive topologicalSortUtil()` `void` `Graph::topologicalSort()` `{` `    ``stack<``int``> Stack;`   `    ``// Mark all the vertices as not visited` `    ``bool``* visited = ``new` `bool``[V];` `    ``for` `(``int` `i = 0; i < V; i++)` `        ``visited[i] = ``false``;`   `    ``// Call the recursive helper function` `    ``// to store Topological` `    ``// Sort starting from all` `    ``// vertices one by one` `    ``for` `(``int` `i = 0; i < V; i++)` `        ``if` `(visited[i] == ``false``)` `            ``topologicalSortUtil(i, visited, Stack);`   `    ``// Print contents of stack` `    ``while` `(Stack.empty() == ``false``) {` `        ``cout << Stack.top() << ``" "``;` `        ``Stack.pop();` `    ``}` `    `  `    ``delete` `[] visited;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Create a graph given in the above diagram` `    ``Graph g(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);`   `    ``cout << ``"Following is a Topological Sort of the given "` `            ``"graph \n"``;`   `    ``// Function Call` `    ``g.topologicalSort();`   `    ``return` `0;` `}`

## Java

 `// A Java program to print topological` `// sorting of a DAG` `import` `java.io.*;` `import` `java.util.*;`   `// This class represents a directed graph` `// using adjacency list representation` `class` `Graph {` `    ``// No. of vertices` `    ``private` `int` `V;`   `    ``// Adjacency List as ArrayList of ArrayList's` `    ``private` `ArrayList > adj;`   `    ``// Constructor` `    ``Graph(``int` `v)` `    ``{` `        ``V = v;` `        ``adj = ``new` `ArrayList >(v);` `        ``for` `(``int` `i = ``0``; i < v; ++i)` `            ``adj.add(``new` `ArrayList());` `    ``}`   `    ``// Function to add an edge into the graph` `    ``void` `addEdge(``int` `v, ``int` `w) { adj.get(v).add(w); }`   `    ``// A recursive function used by topologicalSort` `    ``void` `topologicalSortUtil(``int` `v, ``boolean` `visited[],` `                             ``Stack stack)` `    ``{` `        ``// Mark the current node as visited.` `        ``visited[v] = ``true``;` `        ``Integer i;`   `        ``// Recur for all the vertices adjacent` `        ``// to thisvertex` `        ``Iterator it = adj.get(v).iterator();` `        ``while` `(it.hasNext()) {` `            ``i = it.next();` `            ``if` `(!visited[i])` `                ``topologicalSortUtil(i, visited, stack);` `        ``}`   `        ``// Push current vertex to stack` `        ``// which stores result` `        ``stack.push(``new` `Integer(v));` `    ``}`   `    ``// The function to do Topological Sort.` `    ``// It uses recursive topologicalSortUtil()` `    ``void` `topologicalSort()` `    ``{` `        ``Stack stack = ``new` `Stack();`   `        ``// Mark all the vertices as not visited` `        ``boolean` `visited[] = ``new` `boolean``[V];` `        ``for` `(``int` `i = ``0``; i < V; i++)` `            ``visited[i] = ``false``;`   `        ``// Call the recursive helper` `        ``// function to store` `        ``// Topological Sort starting` `        ``// from all vertices one by one` `        ``for` `(``int` `i = ``0``; i < V; i++)` `            ``if` `(visited[i] == ``false``)` `                ``topologicalSortUtil(i, visited, stack);`   `        ``// Print contents of stack` `        ``while` `(stack.empty() == ``false``)` `            ``System.out.print(stack.pop() + ``" "``);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``// Create a graph given in the above diagram` `        ``Graph g = ``new` `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``);`   `        ``System.out.println(``"Following is a Topological "` `                           ``+ ``"sort of the given graph"``);` `        ``// Function Call` `        ``g.topologicalSort();` `    ``}` `}` `// This code is contributed by Aakash Hasija`

## 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)`   `    ``# A recursive function used by topologicalSort` `    ``def` `topologicalSortUtil(``self``, v, visited, stack):`   `        ``# Mark the current node as visited.` `        ``visited[v] ``=` `True`   `        ``# Recur for all the vertices adjacent to this vertex` `        ``for` `i ``in` `self``.graph[v]:` `            ``if` `visited[i] ``=``=` `False``:` `                ``self``.topologicalSortUtil(i, visited, stack)`   `        ``# Push current vertex to stack which stores result` `        ``stack.append(v)`   `    ``# The function to do Topological Sort. It uses recursive` `    ``# topologicalSortUtil()` `    ``def` `topologicalSort(``self``):` `        ``# Mark all the vertices as not visited` `        ``visited ``=` `[``False``]``*``self``.V` `        ``stack ``=` `[]`   `        ``# Call the recursive helper function to store Topological` `        ``# Sort starting from all vertices one by one` `        ``for` `i ``in` `range``(``self``.V):` `            ``if` `visited[i] ``=``=` `False``:` `                ``self``.topologicalSortUtil(i, visited, stack)`   `        ``# Print contents of the stack` `        ``print``(stack[::``-``1``])  ``# return list in reverse order`     `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``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``(``"Following is a Topological Sort of the given graph"``)`   `    ``# Function Call` `    ``g.topologicalSort()`   `# This code is contributed by Neelam Yadav`

## C#

 `// A C# program to print topological` `// sorting of a DAG` `using` `System;` `using` `System.Collections.Generic;`   `// This class represents a directed graph` `// using adjacency list representation` `class` `Graph {`   `    ``// No. of vertices` `    ``private` `int` `V;`   `    ``// Adjacency List as ArrayList` `    ``// of ArrayList's` `    ``private` `List > adj;`   `    ``// Constructor` `    ``Graph(``int` `v)` `    ``{` `        ``V = v;` `        ``adj = ``new` `List >(v);` `        ``for` `(``int` `i = 0; i < v; i++)` `            ``adj.Add(``new` `List<``int``>());` `    ``}`   `    ``// Function to add an edge into the graph` `    ``public` `void` `AddEdge(``int` `v, ``int` `w) { adj[v].Add(w); }`   `    ``// A recursive function used by topologicalSort` `    ``void` `TopologicalSortUtil(``int` `v, ``bool``[] visited,` `                             ``Stack<``int``> stack)` `    ``{`   `        ``// Mark the current node as visited.` `        ``visited[v] = ``true``;`   `        ``// Recur for all the vertices` `        ``// adjacent to this vertex` `        ``foreach``(``var` `vertex ``in` `adj[v])` `        ``{` `            ``if` `(!visited[vertex])` `                ``TopologicalSortUtil(vertex, visited, stack);` `        ``}`   `        ``// Push current vertex to` `        ``// stack which stores result` `        ``stack.Push(v);` `    ``}`   `    ``// The function to do Topological Sort.` `    ``// It uses recursive topologicalSortUtil()` `    ``void` `TopologicalSort()` `    ``{` `        ``Stack<``int``> stack = ``new` `Stack<``int``>();`   `        ``// Mark all the vertices as not visited` `        ``var` `visited = ``new` `bool``[V];`   `        ``// Call the recursive helper function` `        ``// to store Topological Sort starting` `        ``// from all vertices one by one` `        ``for` `(``int` `i = 0; i < V; i++) {` `            ``if` `(visited[i] == ``false``)` `                ``TopologicalSortUtil(i, visited, stack);` `        ``}`   `        ``// Print contents of stack` `        ``foreach``(``var` `vertex ``in` `stack)` `        ``{` `            ``Console.Write(vertex + ``" "``);` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{`   `        ``// Create a graph given` `        ``// in the above diagram` `        ``Graph g = ``new` `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);`   `        ``Console.WriteLine(``"Following is a Topological "` `                          ``+ ``"sort of the given graph"``);`   `        ``// Function Call` `        ``g.TopologicalSort();` `    ``}` `}`   `// This code is contributed by Abhinav Galodha`

## Javascript

 ``

Output

```Following is a Topological Sort of the given graph
5 4 2 3 1 0 ```

Time Complexity: O(V+E). The above algorithm is simply DFS with an extra stack. So time complexity is the same as DFS
Auxiliary space: O(V). The extra space is needed for the stack

Note: Here, we can also use a vector instead of the stack. If the vector is used then print the elements in reverse order to get the topological sorting.

## Non-recursive approach for topological Sorting:

To solve the problem follow the below idea:

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. 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.

Below is the implementation of the above approach:

## C++

 `#include ` `#include ` `#include ` `#include `   `class` `Graph {` `private``:` `    ``std::unordered_map<``int``, std::vector<``int``> >` `        ``graph; ``// adjacency list` `    ``int` `V; ``// number of vertices` `public``:` `    ``Graph(``int` `vertices)` `        ``: V(vertices)` `    ``{` `    ``}`   `    ``// function to add an edge to graph` `    ``void` `addEdge(``int` `u, ``int` `v) { graph[u].push_back(v); }`   `    ``// non-recursive topological sort` `    ``void` `nonRecursiveTopologicalSort()` `    ``{` `        ``std::vector<``bool``> visited(` `            ``V,` `            ``false``); ``// mark all the vertices as not visited` `        ``std::stack<``int``> stack; ``// result stack`   `        ``// call the helper function to store Topological` `        ``// Sort starting from all vertices one by one` `        ``for` `(``int` `i = 0; i < V; i++) {` `            ``if` `(!visited[i]) {` `                ``nonRecursiveTopologicalSortUtil(i, visited,` `                                                ``stack);` `            ``}` `        ``}`   `        ``// print contents of the stack in reverse` `        ``std::vector<``int``> sorted;` `        ``while` `(!stack.empty()) {` `            ``sorted.push_back(stack.top());` `            ``stack.pop();` `        ``}` `        ``std::cout << ``"The following is a Topological Sort "` `                     ``"of the given graph:\n"``;` `        ``for` `(``auto``& i : sorted) {` `            ``std::cout << i << ``" "``;` `        ``}` `        ``std::cout << std::endl;` `    ``}`   `private``:` `    ``// helper function for non-recursive topological sort` `    ``void` `nonRecursiveTopologicalSortUtil(` `        ``int` `v, std::vector<``bool``>& visited,` `        ``std::stack<``int``>& stack)` `    ``{` `        ``visited[v] = ``true``;`   `        ``for` `(``auto``& next_neighbor : graph[v]) {` `            ``if` `(!visited[next_neighbor]) {` `                ``nonRecursiveTopologicalSortUtil(` `                    ``next_neighbor, visited, stack);` `            ``}` `        ``}` `        ``stack.push(v);` `    ``}` `};`   `int` `main()` `{` `    ``Graph g(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);`   `    ``g.nonRecursiveTopologicalSort();` `    ``return` `0;` `}`

## Java

 `// Java program for above approach` `import` `java.util.*;`   `class` `Graph {` `    ``private` `Map> graph; ``// adjacency list` `    ``private` `int` `V; ``// number of vertices`   `    ``public` `Graph(``int` `vertices) {` `        ``V = vertices;` `        ``graph = ``new` `HashMap>();` `        ``for` `(``int` `i = ``0``; i < V; i++) {` `            ``graph.put(i, ``new` `ArrayList());` `        ``}` `    ``}`   `    ``// function to add an edge to graph` `    ``public` `void` `addEdge(``int` `u, ``int` `v) {` `        ``graph.get(u).add(v);` `    ``}`   `    ``// non-recursive topological sort` `    ``public` `void` `nonRecursiveTopologicalSort() {` `        ``boolean``[] visited = ``new` `boolean``[V]; ``// mark all the vertices as not visited` `        ``Stack stack = ``new` `Stack(); ``// result stack`   `        ``// call the helper function to store Topological ` `        ``// Sort starting from all vertices one by one` `        ``for` `(``int` `i = ``0``; i < V; i++) {` `            ``if` `(!visited[i]) {` `                ``nonRecursiveTopologicalSortUtil(i, visited, stack);` `            ``}` `        ``}`   `        ``// print contents of the stack in reverse` `        ``List sorted = ``new` `ArrayList();` `        ``while` `(!stack.empty()) {` `            ``sorted.add(stack.pop());` `        ``}` `        ``System.out.print(``"The following is a Topological Sort of the given graph:\n"``);` `        ``for` `(``int` `i : sorted) {` `            ``System.out.print(i + ``" "``);` `        ``}` `        ``System.out.println();` `    ``}`   `    ``// helper function for non-recursive topological sort` `    ``private` `void` `nonRecursiveTopologicalSortUtil(``int` `v, ``boolean``[] visited, Stack stack) {` `        ``visited[v] = ``true``;`   `        ``for` `(``int` `nextNeighbor : graph.get(v)) {` `            ``if` `(!visited[nextNeighbor]) {` `                ``nonRecursiveTopologicalSortUtil(nextNeighbor, visited, stack);` `            ``}` `        ``}` `        ``stack.push(v);` `    ``}` `}`   `public` `class` `Main {` `    ``public` `static` `void` `main(String[] args) {` `        ``Graph g = ``new` `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``);`   `        ``g.nonRecursiveTopologicalSort();` `    ``}` `}`   `// This code is contributed by Pushpesh Raj.`

## 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)`     `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `  ``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``)`     `  ``# Function call` `  ``print``(``"The following is a Topological Sort of the given graph"``)` `  ``g.nonRecursiveTopologicalSort()` `# This code was based of Neelam Yadav's code, modified by Suhail Alnahari, Python-ified by Matthias Urlichhs`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `class` `Graph` `{` `  ``private` `Dictionary<``int``, List<``int``>> graph; ``// adjacency list` `  ``private` `int` `V; ``// number of vertices`   `  ``public` `Graph(``int` `vertices)` `  ``{` `    ``V = vertices;` `    ``graph = ``new` `Dictionary<``int``, List<``int``>>();` `    ``for` `(``int` `i = 0; i < V; i++)` `    ``{` `      ``graph[i] = ``new` `List<``int``>();` `    ``}` `  ``}`   `  ``// function to add an edge to graph` `  ``public` `void` `addEdge(``int` `u, ``int` `v)` `  ``{` `    ``graph[u].Add(v);` `  ``}`   `  ``// non-recursive topological sort` `  ``public` `void` `nonRecursiveTopologicalSort()` `  ``{` `    ``bool``[] visited = ``new` `bool``[V]; ``// mark all the vertices as not visited` `    ``Stack<``int``> stack = ``new` `Stack<``int``>(); ``// result stack`   `    ``// call the helper function to store Topological ` `    ``// Sort starting from all vertices one by one` `    ``for` `(``int` `i = 0; i < V; i++)` `    ``{` `      ``if` `(!visited[i])` `      ``{` `        ``nonRecursiveTopologicalSortUtil(i, visited, stack);` `      ``}` `    ``}`   `    ``// print contents of the stack in reverse` `    ``List<``int``> sorted = ``new` `List<``int``>();` `    ``while` `(stack.Count != 0)` `    ``{` `      ``sorted.Add(stack.Pop());` `    ``}` `    ``Console.Write(``"The following is a Topological Sort of the given graph:\n"``);` `    ``foreach` `(``int` `i ``in` `sorted)` `    ``{` `      ``Console.Write(i + ``" "``);` `    ``}` `    ``Console.WriteLine();` `  ``}`   `  ``// helper function for non-recursive topological sort` `  ``private` `void` `nonRecursiveTopologicalSortUtil(``int` `v, ``bool``[] visited, Stack<``int``> stack)` `  ``{` `    ``visited[v] = ``true``;`   `    ``foreach` `(``int` `nextNeighbor ``in` `graph[v])` `    ``{` `      ``if` `(!visited[nextNeighbor])` `      ``{` `        ``nonRecursiveTopologicalSortUtil(nextNeighbor, visited, stack);` `      ``}` `    ``}` `    ``stack.Push(v);` `  ``}` `}`   `public` `class` `MainClass` `{` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``Graph g = ``new` `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);`   `    ``g.nonRecursiveTopologicalSort();` `  ``}` `}`

## Javascript

 `//Javascript Program` ` ``// program to implement stack data structure` `      ``class Stack {` `        ``constructor() {` `          ``this``.items = [];` `        ``}`   `        ``// add element to the stack` `        ``push(element) {` `          ``return` `this``.items.push(element);` `        ``}`   `        ``// remove element from the stack` `        ``pop() {` `          ``if` `(``this``.items.length > 0) {` `            ``return` `this``.items.pop();` `          ``}` `        ``}`   `        ``// view the last element` `        ``top() {` `          ``return` `this``.items[``this``.items.length - 1];` `        ``}`   `        ``// check if the stack is empty` `        ``empty() {` `          ``return` `this``.items.length == 0;` `        ``}`   `        ``// the size of the stack` `        ``size() {` `          ``return` `this``.items.length;` `        ``}`   `        ``// empty the stack` `        ``clear() {` `          ``this``.items = [];` `        ``}` `      ``}`   `      ``class Graph {` `        ``constructor(V) {` `          ``this``.V = V; ``//No. of vertices` `          ``this``.graph = ``new` `Map();` `        ``}` `        ``// function to add an edge to graph` `        ``addEdge(u, v) {` `          ``if` `(``this``.graph.get(u) === undefined) {` `            ``this``.graph.set(u, [v]);` `          ``} ``else` `{` `            ``this``.graph.set(u, ``this``.graph.get(u).push(v));` `          ``}` `        ``}`   `        ``// non-recursive topological sort` `        ``nonRecursiveTopologicalSort() {` `          ``let visited = ``new` `Array(``this``.V);` `          ``visited.fill(``false``); ``// mark all the vertices as not visited` `          ``let stack = ``new` `Stack(); ``// result stack`   `          ``// call the helper function to store Topological Sort starting from all vertices one by one` `          ``for` `(let i = 0; i < ``this``.V; i++) {` `            ``if` `(!visited[i]) {` `              ``this``.nonRecursiveTopologicalSortUtil(i, visited, stack);` `            ``}` `          ``}`   `          ``// print contents of the stack in reverse` `          ``let sorted = ``new` `Array();` `          ``while` `(!stack.empty()) {` `            ``sorted.push(stack.top());` `            ``stack.pop();` `          ``}` `          ``console.log(` `            ``"The following is a Topological Sort of the given graph:"` `          ``);` `          ``for` `(let i ``in` `sorted) {` `            ``console.log(sorted[i]);` `          ``}` `        ``}`   `        ``// helper function for non-recursive topological sort` `        ``nonRecursiveTopologicalSortUtil(v, visited, stack) {` `          ``visited[v] = ``true``;`   `          ``for` `(let j ``in` `this``.graph.get(v)) {` `            ``let next_neighbor = ``this``.graph.get(v)[j];` `            ``if` `(!visited[next_neighbor]) {` `              ``this``.nonRecursiveTopologicalSortUtil(` `                ``next_neighbor,` `                ``visited,` `                ``stack` `              ``);` `            ``}` `          ``}` `          ``stack.push(v);` `        ``}` `      ``}`   `      ``let g = ``new` `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);`   `      ``g.nonRecursiveTopologicalSort();`

Output

```The following is a Topological Sort of the given graph
[5, 4, 2, 3, 1, 0]```

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

## Applications of Topological Sorting:

• Topological Sorting is mainly used for scheduling jobs from the given dependencies among jobs.
• In computer science, applications of this type arise in:
• Instruction scheduling
• Ordering of formula cell evaluation when recomputing formula values in spreadsheets
• Logic synthesis
• Determining the order of compilation tasks to perform in make files
• Data serialization
• Resolving symbol dependencies in linkers

My Personal Notes arrow_drop_up
Related Articles