# Detect cycle in an undirected graph

Given an undirected graph, how to check if there is a cycle in the graph? For example, the following graph has a cycle 1-0-2-1.

We have discussed cycle detection for directed graph. We have also discussed a union-find algorithm for cycle detection in undirected graphs. The time complexity of the union-find algorithm is O(ELogV). Like directed graphs, we can use DFS to detect cycle in an undirected graph in O(V+E) time. We do a DFS traversal of the given graph. For every visited vertex ‘v’, if there is an adjacent ‘u’ such that u is already visited and u is not parent of v, then there is a cycle in graph. If we don’t find such an adjacent for any vertex, we say that there is no cycle. The assumption of this approach is that there are no parallel edges between any two vertices.

## C++

```// A C++ Program to detect cycle in an undirected graph
#include<iostream>
#include <list>
#include <limits.h>
using namespace std;

// Class for an undirected graph
class Graph
{
int V;    // No. of vertices
bool isCyclicUtil(int v, bool visited[], int parent);
public:
Graph(int V);   // Constructor
void addEdge(int v, int w);   // to add an edge to graph
bool isCyclic();   // returns true if there is a cycle
};

Graph::Graph(int V)
{
this->V = V;
}

{
}

// A recursive function that uses visited[] and parent to detect
// cycle in subgraph reachable from vertex v.
bool Graph::isCyclicUtil(int v, bool visited[], int parent)
{
// Mark the current node as visited
visited[v] = true;

// Recur for all the vertices adjacent to this vertex
list<int>::iterator i;
{
// If an adjacent is not visited, then recur for that adjacent
if (!visited[*i])
{
if (isCyclicUtil(*i, visited, v))
return true;
}

// If an adjacent is visited and not parent of current vertex,
// then there is a cycle.
else if (*i != parent)
return true;
}
return false;
}

// Returns true if the graph contains a cycle, else false.
bool Graph::isCyclic()
{
// Mark all the vertices as not visited and not part of recursion
// stack
bool *visited = new bool[V];
for (int i = 0; i < V; i++)
visited[i] = false;

// Call the recursive helper function to detect cycle in different
// DFS trees
for (int u = 0; u < V; u++)
if (!visited[u]) // Don't recur for u if it is already visited
if (isCyclicUtil(u, visited, -1))
return true;

return false;
}

// Driver program to test above functions
int main()
{
Graph g1(5);
g1.isCyclic()? cout << "Graph contains cycle\n":
cout << "Graph doesn't contain cycle\n";

Graph g2(3);
g2.isCyclic()? cout << "Graph contains cycle\n":
cout << "Graph doesn't contain cycle\n";

return 0;
}
```

## Java

```// A Java Program to detect cycle in an undirected graph
import java.io.*;
import java.util.*;

// This class represents a directed graph using adjacency list
// representation
class Graph
{
private int V;   // No. of vertices

// Constructor
Graph(int v) {
V = v;
for(int i=0; i<v; ++i)
}

// Function to add an edge into the graph
}

// A recursive function that uses visited[] and parent to detect
// cycle in subgraph reachable from vertex v.
Boolean isCyclicUtil(int v, Boolean visited[], int parent)
{
// Mark the current node as visited
visited[v] = true;
Integer i;

// Recur for all the vertices adjacent to this vertex
while (it.hasNext())
{
i = it.next();

// If an adjacent is not visited, then recur for that
if (!visited[i])
{
if (isCyclicUtil(i, visited, v))
return true;
}

// If an adjacent is visited and not parent of current
// vertex, then there is a cycle.
else if (i != parent)
return true;
}
return false;
}

// Returns true if the graph contains a cycle, else false.
Boolean isCyclic()
{
// Mark all the vertices as not visited and not part of
// recursion stack
Boolean visited[] = new Boolean[V];
for (int i = 0; i < V; i++)
visited[i] = false;

// Call the recursive helper function to detect cycle in
// different DFS trees
for (int u = 0; u < V; u++)
if (!visited[u]) // Don't recur for u if already visited
if (isCyclicUtil(u, visited, -1))
return true;

return false;
}

// Driver method to test above methods
public static void main(String args[])
{
// Create a graph given in the above diagram
Graph g1 = new Graph(5);
if (g1.isCyclic())
System.out.println("Graph contains cycle");
else
System.out.println("Graph doesn't contains cycle");

Graph g2 = new Graph(3);
if (g2.isCyclic())
System.out.println("Graph contains cycle");
else
System.out.println("Graph doesn't contains cycle");
}
}
// This code is contributed by Aakash Hasija
```

Output:

```Graph contains cycle
Graph doesn't contain cycle```

Time Complexity: The program does a simple DFS Traversal of graph and graph is represented using adjacency list. So the time complexity is O(V+E)

Exercise: Can we use BFS to detect cycle in an undirected graph in O(V+E) time? What about directed graphs?

# Company Wise Coding Practice    Topic Wise Coding Practice

• Prakhar Jain

I think cycle detection using BFS would be possible in O(V + E) for undirected graph but not for directed graph. Correct me if I’m wrong.

• Graphos

How to remove cycles from this graph, means if there is cycle remove an edge so there will be no cycle in the graph, my intention is to convert graph to a tree like structure ?

• rihansh

i think parent does not make any sense for a undirected graph
!!!

• rihansh

hello all
Thanx for such explanation and discussion but i think this can be solved in a more intutive manner . for a undirected graph there exists only tree edges and back edges in the graph and if the given graph is not a tree then there surely exists a cycle right ?? so just do dfs count number of nodes you have visited in a single turn and use this formulla to calculate number of edges V=E+1 and check at the end whether the total number of edges in the graph is equal to summation of all Es in all connected component of a graph correct me if i am wrong !!!

• Himanshu Dagar

The above algorithm shows :- have a cyclic even if i removed node 4 and edge b/w 0 &2 .
It seems to be incorrect

• Nayana

• guest11

@GeeksForGeeks
what is the need of adding same edge again in an undirected graph ??

and it doesn’t correspond to the given image……

• Himanshu Dagar

Exactly
Plz update it as early as possible

• Kartik

Because it is an undirected graph. In an undirected graph, an edge from a vertex u to v means another edge from v to u.

• anonymous
• anonymous

C mein likh dete yaar?

• anonymous

can we conclude that if an undirected graph is a-cyclic then it is a tree?

• Sriharsha g.r.v

can i conclude this ..
if a graph is connected,directed and not acyclic then it is cyclic……???

• Guest

can i conclude this ..
if a graph is connected,directed and acyclic then it is cyclic……???

• Nayana

No. one side u r saying acyclic n other side cyclic. check ur doubt first.

• Rahul Kapoor

y we are checking parent condition ?

• Kaushal

Hi
Can you explain how there is cycle in Graph g1?
If it is typo then it should return ‘Graph doesn’t contain cyclic’.
Thanks

• Kartik

Please note that the graph is undirected. There is a cycle 0-1-2

• arpit

if the graph is undirected,and say has N nodes then if number of edges exceed (N-1) then the graph will certainly have a cycle.. that would be an easier solution,isn’t it?

• Nayana

No. It is not always true.

• Eric

Can u give an example in which it is not true?

Practically it is true. But input can be tricky with a repeat of edge. In that case Number of edges are more yet it is not cyclic.

• pavansrinivas

iterative soln…in JAVA

``` public class Vertex { public char label; public boolean wasVisited; public Vertex(char lab) { label = lab; wasVisited = false; } } public class Graph { private final int MAX_VERTS = 20; private Vertex[] vertexList; private int adjMat[][]; private int nVerts; Stack s ; public Graph() { vertexList = new Vertex[MAX_VERTS]; adjMat = new int[MAX_VERTS][MAX_VERTS]; nVerts = 0; for (int j = 0; j < MAX_VERTS; j++) for (int k = 0; k < MAX_VERTS; k++) adjMat[j][k] = 0; } public void addVertex(char lab) { vertexList[nVerts++] = new Vertex(lab); } public void addEdge(int start, int end) { adjMat[start][end] = 1; adjMat[end][start] = 1; } public void displayVertex(int v) { System.out.print(vertexList[v].label); } private int getAdjUnvisited(int v){ for(int i=0;i<nVerts;i++){ if(adjMat[v][i]==1&&vertexList[i].wasVisited==false){ return i; } } return -1; boolean hasCycles(){ s = new Stack(); vertexList[0].wasVisited = true; s.push(0); while(!s.isEmpty()){ int k = getAdjUnvisited(s.peek()); if(k==-1){ s.pop(); }else{ for(int p = 0;p<nVerts;p++){ if(adjMat[k][p]==1&&vertexList[p].wasVisited==true){ if(p!=s.peek()){ return true; } } } s.push(k); vertexList[k].wasVisited=true; } } for(int j=0; j<nVerts; j++) // reset flags vertexList[j].wasVisited = false; return false; } ```

• gb

Can you please post proper formatted code?

• pavansrinivas

i used proper formatting,but sometimes it is messing up the code ..posting it without formatting

public class Vertex {
public char label;
public boolean wasVisited;
public Vertex(char lab)
{
label = lab;
wasVisited = false;
}
}
public class Graph {
private final int MAX_VERTS = 20;
private Vertex[] vertexList;
private int nVerts;
Stack s ;
public Graph() {
vertexList = new Vertex[MAX_VERTS];
nVerts = 0;
for (int j = 0; j < MAX_VERTS; j++)
for (int k = 0; k < MAX_VERTS; k++)
}
vertexList[nVerts++] = new Vertex(lab);
}
public void addEdge(int start, int end) {
}
public void displayVertex(int v) {
System.out.print(vertexList[v].label);
}
for(int i=0;i<nVerts;i++){
return i;
}
}
return -1;
boolean hasCycles(){
s = new Stack();
vertexList[0].wasVisited = true;
s.push(0);
while(!s.isEmpty()){
if(k==-1){
s.pop();
}else{
for(int p = 0;p<nVerts;p++){
if(p!=s.peek()){
return true;
}
}
}
s.push(k);
vertexList[k].wasVisited=true;
}
}
for(int j=0; j<nVerts; j++) // reset flags
vertexList[j].wasVisited = false;
return false;
}

• pavansrinivas

don’t know why this is happenning..

• pavansrinivas

There is a typo in the driver function…the graph(g1) is not cyclic…E(1,2) is missing..

• Yash Girdhar

so the difference in finding a cycle in a directed graph and a undirected graph is just the use of a parent?

• phoenix

No, for finding a cycle in directed graph, you will have to maintain a separate recursion stack which will contain the elements covered in a particular recursion of dfs. Because in directed graph, just reaching a node twice doesn’t mean that there is a cycle.

• D

Are you sure that doesn’t mean there is a cycle? If you hit the node once… then traveled somewhere… the ended up again hitting that node… then you could travel the same path you went before.. then re hit that node once again.. and repeat. AKA cycle.