- Trending Categories
- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- MS Excel
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP
- Physics
- Chemistry
- Biology
- Mathematics
- English
- Economics
- Psychology
- Social Studies
- Fashion Studies
- Legal Studies

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

# Comparison between Tarjan’s and Kosaraju’s Algorithm

Tarjan’s algorithm is to locate strongly linked components in a directed graph, Robert Tarjan created the graph traversal technique known as Tarjan's algorithm in 1972. Without going over previously processed nodes, it effectively locates and handles each highly related component using a depth-first search strategy and a stack data structure. The algorithm is often employed in computer science and graph theory and has several uses, including algorithm creation, network analysis, and data mining.

Kosaraju’s algorithm consists of two passes over the graph. In the first pass, the graph is traversed in reverse order and a "finish time" is assigned to each node. In the second pass, the nodes are visited in the order of their finish times, and each strongly connected component is identified and marked.

## Tarjan’s Algorithm Method

In this case, the Graph class is defined at the beginning of the program, and its constructor initializes an array of adjacency lists based on the number of vertices in the graph. By including the destination vertex in the adjacency list of the source vertex, the addEdge function adds an edge to the graph.

The SCCUtil method, a recursive DFS-based function utilized by the SCC method to discover the SCC, forms the basis of the programme. The current vertex u, an array of discovery times disc, an array of low values low, an array of vertex stacks st, and an array of boolean values stackMember that tracks whether a vertex is in the stack are the inputs for this function.

The procedure puts the current vertex onto the stack and changes its stackMember value to true after first assigning it a discovery time and a low value. After that, it updates the low values of all the nearby vertices to the current vertex in a recursive manner.

The technique iteratively visits undiscovered vertex vs and modifies the low value of u. The method modifies the low value of u based on the discovery time of v if v is already in the stack.

### Algorithm Tarjan

Initialize the algorithm

Start traversing the graph

Check for strongly connected components

Repeat until all nodes have been visited

Return the strongly connected components

The method pops all vertices off the stack until the current vertex u is popped, prints the popped vertices, and sets their stackMember values to false if u is a head node (i.e., if its low value equals its discovery time).

### Example

// C++ program to find the SCC using // Tarjan's algorithm (single DFS) #include <iostream> #include <list> #include <stack> #define NIL -1 using namespace std; // A class that represents // an directed graph class Graph { // No. of vertices int V; // A dynamic array of adjacency lists list<int>* adj; // A Recursive DFS based function // used by SCC() void SCCUtil(int u, int disc[], int low[], stack<int>* st, bool stackMember[]); public: // Member functions Graph(int V); void addEdge(int v, int w); void SCC(); }; // Constructor Graph::Graph(int V) { this->V = V; adj = new list<int>[V]; } // Function to add an edge to the graph void Graph::addEdge(int v, int w) { adj[v].push_back(w); } // Recursive function to finds the SCC // using DFS traversal void Graph::SCCUtil(int u, int disc[], int low[], stack<int>* st, bool stackMember[]) { static int time = 0; // Initialize discovery time // and low value disc[u] = low[u] = ++time; st->push(u); stackMember[u] = true; // Go through all vertices // adjacent to this list<int>::iterator i; for (i = adj[u].begin(); i != adj[u].end(); ++i) { // v is current adjacent of 'u' int v = *i; // If v is not visited yet, // then recur for it if (disc[v] == -1) { SCCUtil(v, disc, low, st, stackMember); // Check if the subtree rooted // with 'v' has connection to // one of the ancestors of 'u' low[u] = min(low[u], low[v]); } // Update low value of 'u' only of // 'v' is still in stack else if (stackMember[v] == true) low[u] = min(low[u], disc[v]); } // head node found, pop the stack // and print an SCC // Store stack extracted vertices int w = 0; // If low[u] and disc[u] if (low[u] == disc[u]) { // Until stack st is empty while (st->top() != u) { w = (int)st->top(); // Print the node cout << w << " "; stackMember[w] = false; st->pop(); } w = (int)st->top(); cout << w << "\n"; stackMember[w] = false; st->pop(); } } // Function to find the SCC in the graph void Graph::SCC() { // Stores the discovery times of // the nodes int* disc = new int[V]; // Stores the nodes with least // discovery time int* low = new int[V]; // Checks whether a node is in // the stack or not bool* stackMember = new bool[V]; // Stores all the connected ancestors stack<int>* st = new stack<int>(); // Initialize disc and low, // and stackMember arrays for (int i = 0; i < V; i++) { disc[i] = NIL; low[i] = NIL; stackMember[i] = false; } // Recursive helper function to // find the SCC in DFS tree with // vertex 'i' for (int i = 0; i < V; i++) { // If current node is not // yet visited if (disc[i] == NIL) { SCCUtil(i, disc, low, st, stackMember); } } } // Driver Code int main() { // Given a graph Graph g1(5); g1.addEdge(3, 5); g1.addEdge(0, 2); g1.addEdge(2, 1); g1.addEdge(4, 3); g1.addEdge(3, 4); // Function Call to find SCC using // Tarjan's Algorithm g1.SCC(); return 0; }

### Output

1 2 0 4 3

## Method 2- Kosaraju

### Algorithm of Kosaraju

Create a collection of visited nodes and an empty stack upon startup.

Start a depth-first search from the first node in the graph that hasn't been visited for each node. Push each node that was visited throughout the search onto the stack.

Every graph edge should have its orientation reversed.

Pop a node off the stack if it is still filled with nodes. Perform a depth-first search from the node if it hasn't been accessed. Mark each node that was visited during the search as a member of the current highly linked component.

Till all nodes have been visited, repeat

.
Each highly linked component will be recognised and noted at the conclusion of the procedure.

The below C++ code uses Kosaraju's Algorithm to find the Strongly Connected Components (SCCs) in a directed graph. The software defines a class called Graph, which has the following member functions:

Graph(int V): Constructor that takes an input of the number of vertices V and initialises the adjacency list of the graph.

Void addEdge(int v, int w): Using two integers, v and w, as inputs, this method creates an edge connecting vertex v to vertex w in the graph.

Kosaraju's Algorithm is used by the void printSCCs() function to print each SCC in the graph.

The method Graph getTranspose() offers the transposition of the graph.

Vertices are added to a stack in the order of their completing times using the recursive function void fillOrder(int v, bool visited[, stack& Stack], int v).

### Example-2

// C++ program to print the SCC of the // graph using Kosaraju's Algorithm #include <iostream> #include <list> #include <stack> using namespace std; class Graph { // No. of vertices int V; // An array of adjacency lists list<int>* adj; // Member Functions void fillOrder(int v, bool visited[], stack<int>& Stack); void DFSUtil(int v, bool visited[]); public: Graph(int V); void addEdge(int v, int w); void printSCCs(); Graph getTranspose(); }; // Constructor of class Graph::Graph(int V) { this->V = V; adj = new list<int>[V]; } // Recursive function to print DFS // starting from v void Graph::DFSUtil(int v, bool visited[]) { // Mark the current node as // visited and print it visited[v] = true; cout << v <<" "; // Recur for all the vertices // adjacent to this vertex list<int>::iterator i; // Traverse Adjacency List of node v for (i = adj[v].begin(); i != adj[v].end(); ++i) { // If child node *i is unvisited if (!visited[*i]) DFSUtil(*i, visited); } } // Function to get the transpose of // the given graph Graph Graph::getTranspose() { Graph g(V); for (int v = 0; v < V; v++) { // Recur for all the vertices // adjacent to this vertex list<int>::iterator i; for (i = adj[v].begin(); i != adj[v].end(); ++i) { // Add to adjacency list g.adj[*i].push_back(v); } } // Return the reversed graph return g; } // Function to add an Edge to the given // graph void Graph::addEdge(int v, int w) { // Add w to v’s list adj[v].push_back(w); } // Function that fills stack with vertices // in increasing order of finishing times void Graph::fillOrder(int v, bool visited[], stack<int>& Stack) { // Mark the current node as // visited and print it 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 child node *i is unvisited if (!visited[*i]) { fillOrder(*i, visited, Stack); } } // All vertices reachable from v // are processed by now, push v Stack.push(v); } // Function that finds and prints all // strongly connected components void Graph::printSCCs() { stack<int> Stack; // Mark all the vertices as // not visited (For first DFS) bool* visited = new bool[V]; for (int i = 0; i < V; i++) visited[i] = false; // Fill vertices in stack according // to their finishing times for (int i = 0; i < V; i++) if (visited[i] == false) fillOrder(i, visited, Stack); // Create a reversed graph Graph gr = getTranspose(); // Mark all the vertices as not // visited (For second DFS) for (int i = 0; i < V; i++) visited[i] = false; // Now process all vertices in // order defined by Stack while (Stack.empty() == false) { // Pop a vertex from stack int v = Stack.top(); Stack.pop(); // Print SCC of the popped vertex if (visited[v] == false) { gr.DFSUtil(v, visited); cout << endl; } } } // Driver Code int main() { // Given Graph Graph g(5); g.addEdge(1, 0); g.addEdge(0, 2); g.addEdge(2, 1); g.addEdge(1, 3); g.addEdge(2, 4); // Function Call to find the SCC // using Kosaraju's Algorithm g.printSCCs(); return 0; }

### Output

0 1 2 4 3

## Conclusion

In summary, The temporal complexity of Tarjan's and Kosaraju's methods is O(V + E), where V denotes the set of vertices and E denotes the set of edges in a graph. The constant factors in Tarjan's algorithm are significantly lower than those in Kosaraju's approach. Kosaraju's method traverses the graph at least twice, hence the constant factor may be double-time. We may use Kosaraju's approach to produce the SCC that is now active while we finish the second DFS. Once the head of the SCCs sub-tree has been found, printing the SCC with Tarjan's Algorithm takes longer.

Although the linear time complexity of the two approaches is identical, there are some differences in the methodology or processes used for SCC calculations. While Kosaraju's technique runs two DFS (or three DFS if we wish to keep the original graph unmodified) on the graph and is pretty similar to the method for determining the topological ordering of a graph, Tarjan's method just relies on the record of nodes in a DFS to partition the graph.