Topological sorting for **D**irected **A**cyclic **G**raph (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.

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. For example, another topological sorting of the following graph is “4 5 2 0 3 1″. The first vertex in topological sorting is always a vertex with in-degree as 0 (a vertex with no in-coming edges).

Let’s look at few examples with proper explanation,**Example:**

Input:Output:5 4 2 3 1 0Explanation:The topological sorting of a DAG is done in a order such that for every directed edge uv, vertex u comes before v in the ordering. 5 has no incoming edge. 4 has no incoming edge, 2 and 0 have incoming edge from 4 and 5 and 1 is placed at last.

Input:Output:0 3 4 1 2Explanation:0 and 3 have no incoming edge, 4 and 1 has incoming edge from 0 and 3. 2 is placed at last.

A DFS based solution to find a topological sort has already been discussed.

**Solution****: **In this article we will see another way to find the linear ordering of vertices in a directed acyclic graph (DAG). The approach is based on the below fact:

**A DAG G has at least one vertex with in-degree 0 and one vertex with out-degree 0**.**Proof:** There’s a simple proof to the above fact is that a DAG does not contain a cycle which means that all paths will be of finite length. Now let S be the longest path from u(source) to v(destination). Since S is the longest path there can be no incoming edge to u and no outgoing edge from v, if this situation had occurred then S would not have been the longest path

=> indegree(u) = 0 and outdegree(v) = 0

**Algorithm:** Steps involved in finding the topological ordering of a DAG:**Step-1:** Compute in-degree (number of incoming edges) for each of the vertex present in the DAG and initialize the count of visited nodes as 0.

**Step-2: **Pick all the vertices with in-degree as 0 and add them into a queue (Enqueue operation)

**Step-3:** Remove a vertex from the queue (Dequeue operation) and then.

- Increment count of visited nodes by 1.
- Decrease in-degree by 1 for all its neighboring nodes.
- If in-degree of a neighboring nodes is reduced to zero, then add it to the queue.

**Step 5:** Repeat Step 3 until the queue is empty.

**Step 5:** If count of visited nodes is **not** equal to the number of nodes in the graph then the topological sort is not possible for the given graph.

**How to find in-degree of each node?**

There are 2 ways to calculate in-degree of every vertex:

- Take an in-degree array which will keep track of

Traverse the array of edges and simply increase the counter of the destination node by 1.for each node in Nodes indegree[node] = 0; for each edge(src, dest) in Edges indegree[dest]++

Time Complexity: O(V+E)

- Traverse the list for every node and then increment the in-degree of all the nodes connected to it by 1.
for each node in Nodes If (list[node].size()!=0) then for each dest in list indegree[dest]++;

Time Complexity: The outer for loop will be executed V number of times and the inner for loop will be executed E number of times, Thus overall time complexity is O(V+E).

The overall time complexity of the algorithm is O(V+E)

Below is C++ implementation of above algorithm. The implementation uses method 2 discussed above for finding indegrees.

## C++

`// A C++ program to print topological` `// sorting of a graph using indegrees.` `#include <bits/stdc++.h>` `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;` ` ` `public` `:` ` ` `// Constructor` ` ` `Graph(` `int` `V);` ` ` ` ` `// Function to add an edge to graph` ` ` `void` `addEdge(` `int` `u, ` `int` `v);` ` ` ` ` `// 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` `u, ` `int` `v)` `{` ` ` `adj[u].push_back(v);` `}` ` ` `// The function to do` `// Topological Sort.` `void` `Graph::topologicalSort()` `{` ` ` `// Create a vector to store` ` ` `// indegrees of all` ` ` `// vertices. Initialize all` ` ` `// indegrees as 0.` ` ` `vector<` `int` `> in_degree(V, 0);` ` ` ` ` `// Traverse adjacency lists` ` ` `// to fill indegrees of` ` ` `// vertices. This step` ` ` `// takes O(V+E) time` ` ` `for` `(` `int` `u = 0; u < V; u++) {` ` ` `list<` `int` `>::iterator itr;` ` ` `for` `(itr = adj[u].begin();` ` ` `itr != adj[u].end(); itr++)` ` ` `in_degree[*itr]++;` ` ` `}` ` ` ` ` `// Create an queue and enqueue` ` ` `// all vertices with indegree 0` ` ` `queue<` `int` `> q;` ` ` `for` `(` `int` `i = 0; i < V; i++)` ` ` `if` `(in_degree[i] == 0)` ` ` `q.push(i);` ` ` ` ` `// Initialize count of visited vertices` ` ` `int` `cnt = 0;` ` ` ` ` `// Create a vector to store` ` ` `// result (A topological` ` ` `// ordering of the vertices)` ` ` `vector<` `int` `> top_order;` ` ` ` ` `// One by one dequeue vertices` ` ` `// from queue and enqueue` ` ` `// adjacents if indegree of` ` ` `// adjacent becomes 0` ` ` `while` `(!q.empty()) {` ` ` `// Extract front of queue` ` ` `// (or perform dequeue)` ` ` `// and add it to topological order` ` ` `int` `u = q.front();` ` ` `q.pop();` ` ` `top_order.push_back(u);` ` ` ` ` `// Iterate through all its` ` ` `// neighbouring nodes` ` ` `// of dequeued node u and` ` ` `// decrease their in-degree` ` ` `// by 1` ` ` `list<` `int` `>::iterator itr;` ` ` `for` `(itr = adj[u].begin();` ` ` `itr != adj[u].end(); itr++)` ` ` ` ` `// If in-degree becomes zero,` ` ` `// add it to queue` ` ` `if` `(--in_degree[*itr] == 0)` ` ` `q.push(*itr);` ` ` ` ` `cnt++;` ` ` `}` ` ` ` ` `// Check if there was a cycle` ` ` `if` `(cnt != V) {` ` ` `cout << ` `"There exists a cycle in the graph\n"` `;` ` ` `return` `;` ` ` `}` ` ` ` ` `// Print topological order` ` ` `for` `(` `int` `i = 0; i < top_order.size(); i++)` ` ` `cout << top_order[i] << ` `" "` `;` ` ` `cout << endl;` `}` ` ` `// Driver program to test above functions` `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\n"` `;` ` ` `g.topologicalSort();` ` ` ` ` `return` `0;` `}` |

## Java

`// A Java program to print topological` `// sorting of a graph using indegrees` `import` `java.util.*;` ` ` `// Class to represent a graph` `class` `Graph {` ` ` `// No. of vertices` ` ` `int` `V;` ` ` ` ` `// An Array of List which contains` ` ` `// references to the Adjacency List of` ` ` `// each vertex` ` ` `List<Integer> adj[];` ` ` `// Constructor` ` ` `public` `Graph(` `int` `V)` ` ` `{` ` ` `this` `.V = V;` ` ` `adj = ` `new` `ArrayList[V];` ` ` `for` `(` `int` `i = ` `0` `; i < V; i++)` ` ` `adj[i] = ` `new` `ArrayList<Integer>();` ` ` `}` ` ` ` ` `// Function to add an edge to graph` ` ` `public` `void` `addEdge(` `int` `u, ` `int` `v)` ` ` `{` ` ` `adj[u].add(v);` ` ` `}` ` ` `// prints a Topological Sort of the` ` ` `// complete graph` ` ` `public` `void` `topologicalSort()` ` ` `{` ` ` `// Create a array to store` ` ` `// indegrees of all` ` ` `// vertices. Initialize all` ` ` `// indegrees as 0.` ` ` `int` `indegree[] = ` `new` `int` `[V];` ` ` ` ` `// Traverse adjacency lists` ` ` `// to fill indegrees of` ` ` `// vertices. This step takes` ` ` `// O(V+E) time` ` ` `for` `(` `int` `i = ` `0` `; i < V; i++) {` ` ` `ArrayList<Integer> temp` ` ` `= (ArrayList<Integer>)adj[i];` ` ` `for` `(` `int` `node : temp) {` ` ` `indegree[node]++;` ` ` `}` ` ` `}` ` ` ` ` `// Create a queue and enqueue` ` ` `// all vertices with indegree 0` ` ` `Queue<Integer> q` ` ` `= ` `new` `LinkedList<Integer>();` ` ` `for` `(` `int` `i = ` `0` `; i < V; i++) {` ` ` `if` `(indegree[i] == ` `0` `)` ` ` `q.add(i);` ` ` `}` ` ` ` ` `// Initialize count of visited vertices` ` ` `int` `cnt = ` `0` `;` ` ` ` ` `// Create a vector to store result` ` ` `// (A topological ordering of the vertices)` ` ` `Vector<Integer> topOrder = ` `new` `Vector<Integer>();` ` ` `while` `(!q.isEmpty()) {` ` ` `// Extract front of queue` ` ` `// (or perform dequeue)` ` ` `// and add it to topological order` ` ` `int` `u = q.poll();` ` ` `topOrder.add(u);` ` ` ` ` `// Iterate through all its` ` ` `// neighbouring nodes` ` ` `// of dequeued node u and` ` ` `// decrease their in-degree` ` ` `// by 1` ` ` `for` `(` `int` `node : adj[u]) {` ` ` `// If in-degree becomes zero,` ` ` `// add it to queue` ` ` `if` `(--indegree[node] == ` `0` `)` ` ` `q.add(node);` ` ` `}` ` ` `cnt++;` ` ` `}` ` ` ` ` `// Check if there was a cycle` ` ` `if` `(cnt != V) {` ` ` `System.out.println(` ` ` `"There exists a cycle in the graph"` `);` ` ` `return` `;` ` ` `}` ` ` ` ` `// Print topological order` ` ` `for` `(` `int` `i : topOrder) {` ` ` `System.out.print(i + ` `" "` `);` ` ` `}` ` ` `}` `}` `// Driver program to test above functions` `class` `Main {` ` ` `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"` `);` ` ` `g.topologicalSort();` ` ` `}` `}` |

## Python

`# A Python program to print topological sorting of a graph` `# using indegrees` `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)` ` ` ` ` ` ` `# The function to do Topological Sort. ` ` ` `def` `topologicalSort(` `self` `):` ` ` ` ` `# Create a vector to store indegrees of all` ` ` `# vertices. Initialize all indegrees as 0.` ` ` `in_degree ` `=` `[` `0` `]` `*` `(` `self` `.V)` ` ` ` ` `# Traverse adjacency lists to fill indegrees of` ` ` `# vertices. This step takes O(V + E) time` ` ` `for` `i ` `in` `self` `.graph:` ` ` `for` `j ` `in` `self` `.graph[i]:` ` ` `in_degree[j] ` `+` `=` `1` ` ` ` ` `# Create an queue and enqueue all vertices with` ` ` `# indegree 0` ` ` `queue ` `=` `[]` ` ` `for` `i ` `in` `range` `(` `self` `.V):` ` ` `if` `in_degree[i] ` `=` `=` `0` `:` ` ` `queue.append(i)` ` ` ` ` `# Initialize count of visited vertices` ` ` `cnt ` `=` `0` ` ` ` ` `# Create a vector to store result (A topological` ` ` `# ordering of the vertices)` ` ` `top_order ` `=` `[]` ` ` ` ` `# One by one dequeue vertices from queue and enqueue` ` ` `# adjacents if indegree of adjacent becomes 0` ` ` `while` `queue:` ` ` ` ` `# Extract front of queue (or perform dequeue)` ` ` `# and add it to topological order` ` ` `u ` `=` `queue.pop(` `0` `)` ` ` `top_order.append(u)` ` ` ` ` `# Iterate through all neighbouring nodes` ` ` `# of dequeued node u and decrease their in-degree` ` ` `# by 1` ` ` `for` `i ` `in` `self` `.graph[u]:` ` ` `in_degree[i] ` `-` `=` `1` ` ` `# If in-degree becomes zero, add it to queue` ` ` `if` `in_degree[i] ` `=` `=` `0` `:` ` ` `queue.append(i)` ` ` ` ` `cnt ` `+` `=` `1` ` ` ` ` `# Check if there was a cycle` ` ` `if` `cnt !` `=` `self` `.V:` ` ` `print` `"There exists a cycle in the graph"` ` ` `else` `:` ` ` `# Print topological order` ` ` `print` `top_order` ` ` ` ` `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"` `g.topologicalSort()` ` ` `# This code is contributed by Neelam Yadav ` |

**Output:**

Following is a Topological Sort 4 5 2 0 3 1

**Complexity Analysis:**

**Time Complexity:**O(V+E).

The outer for loop will be executed V number of times and the inner for loop will be executed E number of times.**Auxillary Space:**O(V).

The queue needs to store all the vertices of the graph. So the space required is O(V)

This article is contributed by **Chirag Agarwal**. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above