Euler Circuit in a Directed Graph - GeeksforGeeks

28 Jul, 2021
Eulerian Path is a path in graph that visits every edge exactly once. Eulerian Circuit is an Eulerian Path which starts and ends on the same vertex. 
A graph is said to be eulerian if it has a eulerian cycle. We have discussed eulerian circuit for an undirected graph. In this post, the same is discussed for a directed graph.
For example, the following graph has eulerian cycle as {1, 0, 3, 4, 0, 2, 1} 
How to check if a directed graph is eulerian? A directed graph has an eulerian cycle if following conditions are true (Source: Wiki) 1) All vertices with nonzero degree belong to a single strongly connected component. 2) In degree is equal to the out degree for every vertex.
We can detect singly connected component using Kosaraju’s DFS based simple algorithm. 
To compare in degree and out-degree, we need to store in degree and out-degree of every vertex. Out degree can be obtained by the size of an adjacency list. In degree can be stored by creating an array of size equal to the number of vertices. 
Following implementations of above approach. 
C++
Java
Python3
C#
Javascript
// A C++ program to check if a given directed graph is Eulerian or not#include<iostream>#include <list>#define CHARS 26using namespace std; // A class that represents an undirected graphclass Graph{    int V;    // No. of vertices    list<int> *adj;    // A dynamic array of adjacency lists    int *in;public:    // Constructor and destructor    Graph(int V);    ~Graph()   { delete [] adj; delete [] in; }     // function to add an edge to graph    void addEdge(int v, int w) { adj[v].push_back(w);  (in[w])++; }     // Method to check if this graph is Eulerian or not    bool isEulerianCycle();     // Method to check if all non-zero degree vertices are connected    bool isSC();     // Function to do DFS starting from v. Used in isConnected();    void DFSUtil(int v, bool visited[]);     Graph getTranspose();}; Graph::Graph(int V){    this->V = V;    adj = new list<int>[V];    in = new int[V];    for (int i = 0; i < V; i++)       in[i] = 0;} /* This function returns true if the directed graph has a eulerian   cycle, otherwise returns false  */bool Graph::isEulerianCycle(){    // Check if all non-zero degree vertices are connected    if (isSC() == false)        return false;     // Check if in degree and out degree of every vertex is same    for (int i = 0; i < V; i++)        if (adj[i].size() != in[i])            return false;     return true;} // A recursive function to do DFS starting from vvoid Graph::DFSUtil(int v, bool visited[]){    // 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 (!visited[*i])            DFSUtil(*i, visited);} // Function that returns reverse (or transpose) of this graph// This function is needed in isSC()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)        {            g.adj[*i].push_back(v);            (g.in[v])++;        }    }    return g;} // This function returns true if all non-zero degree vertices of// graph are strongly connected (Please refer// https://www.geeksforgeeks.org/connectivity-in-a-directed-graph/ )bool Graph::isSC(){    // Mark all the vertices as not visited (For first DFS)    bool visited[V];    for (int i = 0; i < V; i++)        visited[i] = false;     // Find the first vertex with non-zero degree    int n;    for (n = 0; n < V; n++)        if (adj[n].size() > 0)          break;     // Do DFS traversal starting from first non zero degrees vertex.    DFSUtil(n, visited);      // If DFS traversal doesn't visit all vertices, then return false.    for (int i = 0; i < V; i++)        if (adj[i].size() > 0 && visited[i] == false)              return false;     // 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;     // Do DFS for reversed graph starting from first vertex.    // Starting Vertex must be same starting point of first DFS    gr.DFSUtil(n, visited);     // If all vertices are not visited in second DFS, then    // return false    for (int i = 0; i < V; i++)        if (adj[i].size() > 0 && visited[i] == false)             return false;     return true;} // Driver program to test above functionsint main(){    // Create a graph given in the above diagram    Graph g(5);    g.addEdge(1, 0);    g.addEdge(0, 2);    g.addEdge(2, 1);    g.addEdge(0, 3);    g.addEdge(3, 4);    g.addEdge(4, 0);     if (g.isEulerianCycle())       cout << "Given directed graph is eulerian n";    else       cout << "Given directed graph is NOT eulerian n";    return 0;}
// A Java program to check if a given directed graph is Eulerian or not // A class that represents an undirected graphimport java.io.*;import java.util.*;import java.util.LinkedList; // This class represents a directed graph using adjacency listclass Graph{    private int V;   // No. of vertices    private LinkedList<Integer> adj[];//Adjacency List    private int in[];            //maintaining in degree     //Constructor    Graph(int v)    {        V = v;        adj = new LinkedList[v];        in = new int[V];        for (int i=0; i<v; ++i)        {            adj[i] = new LinkedList();            in[i]  = 0;        }    }     //Function to add an edge into the graph    void addEdge(int v,int w)    {        adj[v].add(w);        in[w]++;    }     // A recursive function to print DFS starting from v    void DFSUtil(int v,Boolean visited[])    {        // Mark the current node as visited        visited[v] = true;         int n;         // Recur for all the vertices adjacent to this vertex        Iterator<Integer> i =adj[v].iterator();        while (i.hasNext())        {            n = i.next();            if (!visited[n])                DFSUtil(n,visited);        }    }     // Function that returns reverse (or transpose) of this graph    Graph getTranspose()    {        Graph g = new Graph(V);        for (int v = 0; v < V; v++)        {            // Recur for all the vertices adjacent to this vertex            Iterator<Integer> i = adj[v].listIterator();            while (i.hasNext())            {                g.adj[i.next()].add(v);                (g.in[v])++;            }        }        return g;    }     // The main function that returns true if graph is strongly    // connected    Boolean isSC()    {        // Step 1: Mark all the vertices as not visited (For        // first DFS)        Boolean visited[] = new Boolean[V];        for (int i = 0; i < V; i++)            visited[i] = false;         // Step 2: Do DFS traversal starting from the first vertex.        DFSUtil(0, visited);         // If DFS traversal doesn't visit all vertices, then return false.        for (int i = 0; i < V; i++)            if (visited[i] == false)                return false;         // Step 3: Create a reversed graph        Graph gr = getTranspose();         // Step 4: Mark all the vertices as not visited (For second DFS)        for (int i = 0; i < V; i++)            visited[i] = false;         // Step 5: Do DFS for reversed graph starting from first vertex.        // Starting Vertex must be same starting point of first DFS        gr.DFSUtil(0, visited);         // If all vertices are not visited in second DFS, then        // return false        for (int i = 0; i < V; i++)            if (visited[i] == false)                return false;         return true;    }     /* This function returns true if the directed graph has a eulerian       cycle, otherwise returns false  */    Boolean isEulerianCycle()    {        // Check if all non-zero degree vertices are connected        if (isSC() == false)            return false;         // Check if in degree and out degree of every vertex is same        for (int i = 0; i < V; i++)            if (adj[i].size() != in[i])                return false;         return true;    }     public static void main (String[] args) throws java.lang.Exception    {        Graph g = new Graph(5);        g.addEdge(1, 0);        g.addEdge(0, 2);        g.addEdge(2, 1);        g.addEdge(0, 3);        g.addEdge(3, 4);        g.addEdge(4, 0);         if (g.isEulerianCycle())            System.out.println("Given directed graph is eulerian ");        else            System.out.println("Given directed graph is NOT eulerian ");    }}//This code is contributed by Aakash Hasija
# A Python3 program to check if a given# directed graph is Eulerian or not from collections import defaultdict class Graph():     def __init__(self, vertices):        self.V = vertices        self.graph = defaultdict(list)        self.IN = [0] * vertices     def addEdge(self, v, u):         self.graph[v].append(u)        self.IN[u] += 1     def DFSUtil(self, v, visited):        visited[v] = True        for node in self.graph[v]:            if visited[node] == False:                self.DFSUtil(node, visited)     def getTranspose(self):        gr = Graph(self.V)         for node in range(self.V):            for child in self.graph[node]:                gr.addEdge(child, node)         return gr     def isSC(self):        visited = [False] * self.V         v = 0        for v in range(self.V):            if len(self.graph[v]) > 0:                break         self.DFSUtil(v, visited)         # If DFS traversal doesn't visit all        # vertices, then return false.        for i in range(self.V):            if visited[i] == False:                return False         gr = self.getTranspose()         visited = [False] * self.V        gr.DFSUtil(v, visited)         for i in range(self.V):            if visited[i] == False:                return False         return True     def isEulerianCycle(self):         # Check if all non-zero degree vertices        # are connected        if self.isSC() == False:            return False         # Check if in degree and out degree of        # every vertex is same        for v in range(self.V):            if len(self.graph[v]) != self.IN[v]:                return False         return True  g = Graph(5);g.addEdge(1, 0);g.addEdge(0, 2);g.addEdge(2, 1);g.addEdge(0, 3);g.addEdge(3, 4);g.addEdge(4, 0);if g.isEulerianCycle():   print( "Given directed graph is eulerian");else:   print( "Given directed graph is NOT eulerian"); # This code is contributed by Divyanshu Mehta
// A C# program to check if a given// directed graph is Eulerian or not // A class that represents an// undirected graphusing System;using System.Collections.Generic; // This class represents a directed// graph using adjacency listclass Graph{     // No. of verticespublic int V;   // Adjacency Listpublic List<int> []adj; // Maintaining in degreepublic int []init;           // ConstructorGraph(int v){    V = v;    adj = new List<int>[v];    init = new int[V];         for(int i = 0; i < v; ++i)    {        adj[i] = new List<int>();        init[i]  = 0;    }} // Function to add an edge into the graphvoid addEdge(int v, int w){    adj[v].Add(w);    init[w]++;} // A recursive function to print DFS// starting from vvoid DFSUtil(int v, Boolean []visited){         // Mark the current node as visited    visited[v] = true;     // Recur for all the vertices    // adjacent to this vertex    foreach(int i in adj[v])    {                 if (!visited[i])            DFSUtil(i, visited);    }} // Function that returns reverse// (or transpose) of this graphGraph getTranspose(){    Graph g = new Graph(V);    for(int v = 0; v < V; v++)    {                 // Recur for all the vertices        // adjacent to this vertex        foreach(int i in adj[v])        {            g.adj[i].Add(v);            (g.init[v])++;        }    }    return g;} // The main function that returns// true if graph is strongly connectedBoolean isSC(){         // Step 1: Mark all the vertices    // as not visited (For first DFS)    Boolean []visited = new Boolean[V];    for(int i = 0; i < V; i++)        visited[i] = false;     // Step 2: Do DFS traversal starting    // from the first vertex.    DFSUtil(0, visited);     // If DFS traversal doesn't visit    // all vertices, then return false.    for(int i = 0; i < V; i++)        if (visited[i] == false)            return false;     // Step 3: Create a reversed graph    Graph gr = getTranspose();     // Step 4: Mark all the vertices as    // not visited (For second DFS)    for(int i = 0; i < V; i++)        visited[i] = false;     // Step 5: Do DFS for reversed graph    // starting from first vertex.    // Staring Vertex must be same    // starting point of first DFS    gr.DFSUtil(0, visited);     // If all vertices are not visited    // in second DFS, then return false    for(int i = 0; i < V; i++)        if (visited[i] == false)            return false;     return true;} // This function returns true if the// directed graph has a eulerian// cycle, otherwise returns false Boolean isEulerianCycle(){         // Check if all non-zero degree    // vertices are connected    if (isSC() == false)        return false;     // Check if in degree and out    // degree of every vertex is same    for(int i = 0; i < V; i++)        if (adj[i].Count != init[i])            return false;     return true;} // Driver codepublic static void Main(String[] args){    Graph g = new Graph(5);    g.addEdge(1, 0);    g.addEdge(0, 2);    g.addEdge(2, 1);    g.addEdge(0, 3);    g.addEdge(3, 4);    g.addEdge(4, 0);         if (g.isEulerianCycle())        Console.WriteLine("Given directed " +                          "graph is eulerian ");    else        Console.WriteLine("Given directed " +                          "graph is NOT eulerian ");}} // This code is contributed by Princi Singh
<script>// A Javascript program to check if a given directed graph is Eulerian or not // This class represents a directed graph using adjacency// list representationclass Graph{    // Constructor    constructor(v)    {        this.V = v;        this.adj = new Array(v);                 this.in=new Array(v);        for (let i=0; i<v; ++i)        {               this.adj[i] = [];            this.in[i]=0;        }    }         //Function to add an edge into the graph    addEdge(v,w)    {        this.adj[v].push(w);         this.in[w]++;             }         // A recursive function to print DFS starting from v    DFSUtil(v,visited)    {        // Mark the current node as visited        visited[v] = true;          let n;          // Recur for all the vertices adjacent to this vertex                 for(let i of this.adj[v])        {            n = i;            if (!visited[n])                this.DFSUtil(n,visited);        }    }         // Function that returns reverse (or transpose) of this graph    getTranspose()    {        let g = new Graph(this.V);        for (let v = 0; v < this.V; v++)        {            // Recur for all the vertices adjacent to this vertex                         for(let i of this.adj[v])            {                g.adj[i].push(v);                (g.in[v])++;            }        }        return g;    }         // The main function that returns true if graph is strongly    // connected    isSC()    {        // Step 1: Mark all the vertices as not visited (For        // first DFS)        let visited = new Array(this.V);        for (let i = 0; i < this.V; i++)            visited[i] = false;          // Step 2: Do DFS traversal starting from the first vertex.        this.DFSUtil(0, visited);          // If DFS traversal doesn't visit all vertices, then return false.        for (let i = 0; i < this.V; i++)            if (visited[i] == false)                return false;          // Step 3: Create a reversed graph        let gr = this.getTranspose();          // Step 4: Mark all the vertices as not visited (For second DFS)        for (let i = 0; i < this.V; i++)            visited[i] = false;          // Step 5: Do DFS for reversed graph starting from first vertex.        // Starting Vertex must be same starting point of first DFS        gr.DFSUtil(0, visited);          // If all vertices are not visited in second DFS, then        // return false        for (let i = 0; i < this.V; i++)            if (visited[i] == false)                return false;          return true;    }         /* This function returns true if the directed graph has a eulerian       cycle, otherwise returns false  */    isEulerianCycle()    {        // Check if all non-zero degree vertices are connected        if (this.isSC() == false)            return false;          // Check if in degree and out degree of every vertex is same        for (let i = 0; i < this.V; i++)            if (this.adj[i].length != this.in[i])                return false;          return true;    }} let g = new Graph(5);g.addEdge(1, 0);g.addEdge(0, 2);g.addEdge(2, 1);g.addEdge(0, 3);g.addEdge(3, 4);g.addEdge(4, 0); if (g.isEulerianCycle())    document.write("Given directed graph is eulerian ");else    document.write("Given directed graph is NOT eulerian ");  // This code is contributed by avanitrachhadiya2155</script>
Output: 
Given directed graph is eulerian 
 Time complexity of the above implementation is O(V + E) as Kosaraju’s algorithm takes O(V + E) time. After running Kosaraju’s algorithm we traverse all vertices and compare in degree with out degree which takes O(V) time. 
See following as an application of this. Find if the given array of strings can be chained to form a circle.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
 
UtkarshVerma12
princi singh
khushboogoyal499
avanitrachhadiya2155
DFS
Euler-Circuit
graph-connectivity
graph-cycle
Graph
DFS
Graph
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Topological Sorting
Detect Cycle in a Directed Graph
Travelling Salesman Problem | Set 1 (Naive and Dynamic Programming)
Ford-Fulkerson Algorithm for Maximum Flow Problem
Disjoint Set (Or Union-Find) | Set 1 (Detect Cycle in an Undirected Graph)
Traveling Salesman Problem (TSP) Implementation
Detect cycle in an undirected graph
Hamiltonian Cycle | Backtracking-6
m Coloring Problem | Backtracking-5
Find the number of islands | Set 1 (Using DFS)