Topological Sorting

A topological sort or topological ordering of a directed graph is a linear ordering of its vertices in which u occurs before v in the ordering for every directed edge uv from vertex u to vertex v. For example, the graph's vertices could represent jobs to be completed, and the edges could reflect requirements that one work must be completed before another.

In this case, a topological ordering is just a legitimate task sequence. A topological sort is a graph traversal in which each node v is only visited after all of its dependencies have been visited. If the graph contains no directed cycles, then it is a directed acyclic graph. Any DAG has at least one topological ordering, and there exist techniques for building topological orderings in linear time for any DAG.

Topological sorting has many applications, particularly in ranking issues like the feedback arc set. Even if the DAG includes disconnected components, topological sorting is possible.

Java Code

Now let's write a sample java code for topological sorting.

// A Sample Java program to print topological sorting of a Directed Acyclic Graph(DAG)
import java.io.*;
import java.util.*;
// A class named Graph is created that will represent a directed graph using adjacency list representation 
class Graph {	
	// A private variable named V of the Integer type is created that will be used to represent the number of nodes in the Directed Acyclic Graph
	private int V;
	// A private variable named adj of ArrayList type is created that will represent Adjacency List as ArrayList of ArrayList's
	private ArrayList<ArrayList<Integer> > adj;
	// A parameterized constructor is written that will be used to initialize the class variables of the Graph class
	Graph(int v)
	{
		V = v;
		adj = new ArrayList<ArrayList<Integer> >(v);
		for (int i = 0; i < v; ++i)
			adj.add(new ArrayList<Integer> ());
	}
	// Function to add an edge into the graph
	// A Function named addEdge is written that will be used to add a new edge into the Directed Acyclic Graph  
	void addEdge(int v, int w) { 
		// With the use of add() a new edge will be added into the Directed Acyclic Graph
		adj.get(v).add(w); 
	}
	// A recursive function used by topologicalSort
	// A recursive function named topologicalSortUtil is written that will be used to perform the topological sorting on the edges of the Directed Acyclic Graph
	void topologicalSortUtil(int v, boolean visited[],
							Stack<Integer>  stack)
	{
		// Mark the current node as visited.
		visited[v] = true;
		Integer i;
		// Recur for all the vertices adjacent
		// to thisvertex
		Iterator<Integer> 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()
	// A Function named topologicalSort() is written that will be used to call the recursive function named topologicalSortUtil to sort the edges of the Directed Acyclic Graph 
	void topologicalSort()
	{
		Stack<Integer> stack = new Stack<Integer>();
		// 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() + " ");
	}
	// main function is written to call all the functionalities functions written above
	public static void main(String args[])
	{
		// Now, let us create a graph, and for that, we will create the edges of the Directed Acyclic Graph 
		// A Directed Acyclic Graph with six nodes is created for that an Object of the graph node is created by calling the constructor of the graph class
		Graph g = new Graph(26);
		Scanner scan = new Scanner(System.in);
		char ch;
       /*  Perform list operations  */
        do
            {
                System.out.println("Please Choose one of the Operations::");
                System.out.println("1. To create a Directed Acyclic Graph (DAG) for topological sort.");
                System.out.println("2. To print the result of the topological sort.");
                int choice = scan.nextInt();
                switch (choice)
                    {
                    case 1 :
						// A edge starting from vertex 25 and terminating at the vertex 10  is created by calling the addEdge() with passing these starting and terminating vertex to this function 
						g.addEdge(25, 10);
						// A edge starting from vertex 25 and terminating at the vertex 0 is created by calling the addEdge() with passing these starting and terminating vertex to this function
						g.addEdge(25, 0);
						// A edge starting from vertex 20 and terminating at the vertex 0 is created by calling the addEdge() with passing these starting and terminating vertex to this function
						g.addEdge(20, 0);
						// A edge starting from vertex 20 and terminating at the vertex 5 is created by calling the addEdge() with passing these starting and terminating vertex to this function
						g.addEdge(20, 5);
						// A edge starting from vertex 10 and terminating at the vertex 15 is created by calling the addEdge() with passing these starting and terminating vertex to this function
						g.addEdge(10, 15);
						// A edge starting from vertex 15 and terminating at the vertex 5 is created by calling the addEdge() with passing these starting and terminating vertex to this function
						g.addEdge(15, 5);
                        break;
                    case 2 :
        				System.out.println("The result after topological sort of the Directed Acyclic Graph");
						g.topologicalSort();                
                        break;
                    default :
                        System.out.println("Wrong Entry\n ");
                        break;
                    }
                System.out.println("\nDo you want to continue (Type y or n)\n");
                ch = scan.next().charAt(0);
            }
        while (ch == 'Y'|| ch == 'y');		
	}
}

Output

The above Java code gives the following output.

Please Choose one of the Operations::
1. To create a Directed Acyclic Graph (DAG) for topological sort.
2. To print the result of the topological sort.
1
Directed Acyclic Graph (DAG) created successfully.
Do you want to continue (Type y or n)
y
Please Choose one of the Operations::
1. To create a Directed Acyclic Graph (DAG) for topological sort.
2. To print the result of the topological sort.
2
The result after topological sort of the Directed Acyclic Graph
25  20 15 10 5  0 
Do you want to continue (Type y or n)
n

So, in the above Java code, we have created a class named Graph that will represent a directed graph using adjacency list representation. Different member functions to perform various operations like adding a new node in the graph are also written. A function named topologicalSort() is written to perform the actual task of the topological sort of the graph. The topologicalSort() function internally calls a recursive function named topologicalSortUtil() that consists of the actual logic of the topological sorting of the graph. Once the topological sorting is performed on the graph, the graph's nodes are printed due to the topological operation.

C++ Code

Let's see the C++ code,

// A Sample C++ program to print topological sorting of a Directed Acyclic Graph(DAG)
#include <iostream>	
#include <list>
#include <stack>
using namespace std;
// A class named Graph is created that will represent a directed graph using adjacency list representation 
class Graph {
	// A variable named V of the Integer type is created that will be used to represent the number of nodes in the Directed Acyclic Graph
	int V;
	// Pointer to an array containing adjacency listsList
	list<int>* adj;
	// A recursive function named topologicalSortUtil is written that will be used to perform the topological sorting on the edges of the Directed Acyclic Graph
	void topologicalSortUtil(int v, bool visited[],
							stack<int>& Stack);
public:
	// A parameterized constructor is written that will be used to initialize the class variables of the Graph class
	Graph(int V);
	// A Function named addEdge is written that will be used to add a new edge into the Directed Acyclic Graph  
	void addEdge(int v, int w);
	// A Function named topologicalSort() is written that will be used to call the recursive function named topologicalSortUtil to sort the edges of the Directed Acyclic Graph 
	void topologicalSort();
};
// A parameterized constructor is written that will be used to initialize the class variables of the Graph class
Graph::Graph(int V)
{
	this->V = V;
	adj = new list<int>[V];
}
// A Function named addEdge is written that will be used to add a new edge into the Directed Acyclic Graph  
void Graph::addEdge(int v, int w)
{
	// Add w to v's list.
	adj[v].push_back(w);
}
// A recursive function named topologicalSortUtil is written that will be used to perform the topological sorting on the edges of the Directed Acyclic Graph
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);
}
// A Function named topologicalSort() is written that will be used to call the recursive function named topologicalSortUtil to sort the edges of the Directed Acyclic Graph 
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();
	}
}
// main function is written to call all the functionalities functions written above
int main()
{
	// Now, let us create a graph, and for that, we will create the edges of the Directed Acyclic Graph 
	Graph g(6);
	// A edge starting from vertex 5 and terminating at vertex 2  is created by calling the addEdge() with passing these starting and terminating vertex to this function 
	g.addEdge(5, 2);
	// A edge starting from vertex 5 and terminating at the vertex 0  is created by calling the addEdge() with passing these starting and terminating vertex to this function 
	g.addEdge(5, 0);
	// A edge starting from vertex 4 and terminating at the vertex 0  is created by calling the addEdge() with passing these starting and terminating vertex to this function 
	g.addEdge(4, 0);
	// A edge starting from vertex 4 and terminating at the vertex 1  is created by calling the addEdge() with passing these starting and terminating vertex to this function 
	g.addEdge(4, 1);
	// A edge starting from vertex 2 and terminating at the vertex 3  is created by calling the addEdge() with passing these starting and terminating vertex to this function 
	g.addEdge(2, 3);
	// A edge starting from vertex 3 and terminating at the vertex 1  is created by calling the addEdge() with passing these starting and terminating vertex to this function 
	g.addEdge(3, 1);
	cout<<"Directed Acyclic Graph (DAG) created successfully.\n";
	cout << "The result of topological Sort is\n";
	g.topologicalSort();
	return 0;
}

Output

The above C++ code gives the following output.

Directed Acyclic Graph (DAG) created successfully.
The result of topological Sort is
5 4 2 3 1 0

So, in the above C++ code, we created a class named Graph that will represent a directed graph using adjacency list representation. Different member functions to perform various operations like adding a new node in the Graph are also written. Then a function named topologicalSort() is written to perform the actual task of the topological sort of the graph. The topologicalSort() function internally calls a recursive function named topologicalSortUtil() that consists of the actual logic of the topological sorting of the graph. Once the topological sorting is performed on the graph, the graph's nodes are printed due to the topological operation.

Advantages of Topological Sorting

Topological Sorting is mostly used to schedule jobs based on their dependencies. Instruction scheduling, ordering formula cell evaluation when recomputing formula values in spreadsheets, logic synthesis, determining the order of compilation tasks to perform in make files, data serialization, and resolving symbol dependencies in linker are all examples of applications of this type in computer science.

Finding cycle in a graph: Only directed acyclic graphs may be ordered topologically (DAG). It is impossible to arrange a circular graph topologically.
Operation System deadlock detection: A deadlock occurs when one process is waiting while another holds the requested resource.
Dependency resolution: Topological Sorting has been proved to be very helpful in Dependency resolution.
Sentence Ordering: A set of n documents D={d1,d2...,dn} and the number of sentences in a document is vi, where ∀i, vi>=1. Suppose a random order o=[o1,....ovi] and a set of vi sentences in random order are {So1, So2,..., Sovi}. Then the task is to find the right order of the sentences o*={o*1,...o*vi}. A set of constraints Ci represents the relative ordering between every pair of sentences in di where |Ci|=(vi�(vi-1))/2. For example, if a document has three sentences in the correct order s1 < s2 < s3, then we have three set of constraints {s1 < s2, s1 < s3, s2 < s3}
The order of the sentences can be represented using a DAG. Here the sentences (Si) represent the vertices, and the edges represent the ordering between sentences. For example, if we have a directed edge between S1 to S2, then S1 must come before S2. Topological sort can produce an ordering of these sentences (Sentence ordering).
Critical Path Analysis: A project management approach known as critical route analysis. It's used to figure out how long a project should take and how dependent each action is on the others. There may be some preceding actions before an activity. Before beginning a new activity, all previous actions must be completed.
Course Schedule problem: Topological Sorting has been proved to be very helpful in solving the Course Schedule problem.
Other applications like manufacturing workflows, data serialization, and context-free grammar.

Next TopicTernary Search Tree

← prev next →