Related Articles

# Detect cycle in an undirected graph using BFS

• Difficulty Level : Medium
• Last Updated : 02 Jul, 2021

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 the 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 a cycle in an undirected graph in O(V+E) time. We have discussed DFS based solution for cycle detection in an undirected graph
In this article, the BFS based solution is discussed. We do a BFS 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 a parent of v, then there is a cycle in the graph. If we don’t find such an adjacent for any vertex, we say that there is no cycle.
We use a parent array to keep track of the parent vertex for a vertex so that we do not consider the visited parent as a cycle.

## C++

 `// C++ program to detect cycle``// in an undirected graph``// using BFS.``#include ``using` `namespace` `std;` `void` `addEdge(vector<``int``> adj[], ``int` `u, ``int` `v)``{``    ``adj[u].push_back(v);``    ``adj[v].push_back(u);``}` `bool` `isCyclicConntected(vector<``int``> adj[], ``int` `s,``                        ``int` `V, vector<``bool``>& visited)``{``    ``// Set parent vertex for every vertex as -1.``    ``vector<``int``> parent(V, -1);` `    ``// Create a queue for BFS``    ``queue<``int``> q;` `    ``// Mark the current node as``    ``// visited and enqueue it``    ``visited[s] = ``true``;``    ``q.push(s);` `    ``while` `(!q.empty()) {` `        ``// Dequeue a vertex from queue and print it``        ``int` `u = q.front();``        ``q.pop();` `        ``// Get all adjacent vertices of the dequeued``        ``// vertex u. If a adjacent has not been visited,``        ``// then mark it visited and enqueue it. We also``        ``// mark parent so that parent is not considered``        ``// for cycle.``        ``for` `(``auto` `v : adj[u]) {``            ``if` `(!visited[v]) {``                ``visited[v] = ``true``;``                ``q.push(v);``                ``parent[v] = u;``            ``}``            ``else` `if` `(parent[u] != v)``                ``return` `true``;``        ``}``    ``}``    ``return` `false``;``}` `bool` `isCyclicDisconntected(vector<``int``> adj[], ``int` `V)``{``    ``// Mark all the vertices as not visited``    ``vector<``bool``> visited(V, ``false``);` `    ``for` `(``int` `i = 0; i < V; i++)``        ``if` `(!visited[i] && isCyclicConntected(adj, i,``                                         ``V, visited))``            ``return` `true``;``    ``return` `false``;``}` `// Driver program to test methods of graph class``int` `main()``{``    ``int` `V = 4;``    ``vector<``int``> adj[V];``    ``addEdge(adj, 0, 1);``    ``addEdge(adj, 1, 2);``    ``addEdge(adj, 2, 0);``    ``addEdge(adj, 2, 3);` `    ``if` `(isCyclicDisconntected(adj, V))``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;` `    ``return` `0;``}`

## Java

 `// Java program to detect cycle in``//  an undirected graph using BFS.``import` `java.util.ArrayList;``import` `java.util.Arrays;``import` `java.util.LinkedList;``import` `java.util.Queue;` `class` `cycle``{``    ` `  ``public` `static` `void` `main(String arg[])``  ``{` `    ``int` `V = ``4``;``    ``@SuppressWarnings``(``"unchecked"``)``    ``ArrayList adj[] = ``new` `ArrayList[V];``    ``for``(``int` `i = ``0``; i < ``4``; i++)``      ``adj[i] = ``new` `ArrayList();` `    ``addEdge(adj, ``0``, ``1``);``    ``addEdge(adj, ``1``, ``2``);``    ``addEdge(adj, ``2``, ``0``);``    ``addEdge(adj, ``2``, ``3``);` `    ``if` `(isCyclicDisconntected(adj, V))``      ``System.out.println(``"Yes"``);``    ``else``      ``System.out.println(``"No"``);``  ``}` `  ``static` `void` `addEdge(ArrayList adj[], ``int` `u, ``int` `v)``  ``{``    ``adj[u].add(v);``    ``adj[v].add(u);``  ``}` `  ``static` `boolean` `isCyclicConntected(``                             ``ArrayList adj[], ``int` `s,``                                    ``int` `V, ``boolean` `visited[])``  ``{` `    ``// Set parent vertex for every vertex as -1.``    ``int` `parent[] = ``new` `int``[V];``    ``Arrays.fill(parent, -``1``);` `    ``// Create a queue for BFS``    ``Queue q = ``new` `LinkedList<>();` `    ``// Mark the current node as``    ``// visited and enqueue it``    ``visited[s] = ``true``;``    ``q.add(s);` `    ``while` `(!q.isEmpty())``    ``{` `      ``// Dequeue a vertex from``      ``// queue and print it``      ``int` `u = q.poll();`  `      ``// Get all adjacent vertices``      ``// of the dequeued vertex u.``      ``// If a adjacent has not been``      ``// visited, then mark it visited``      ``// and enqueue it. We also mark parent``      ``// so that parent is not considered``      ``// for cycle.``      ``for` `(``int` `i = ``0``; i < adj[u].size(); i++)``      ``{``        ``int` `v = adj[u].get(i);``        ``if` `(!visited[v])``        ``{``          ``visited[v] = ``true``;``          ``q.add(v);``          ``parent[v] = u;``        ``}``        ``else` `if` `(parent[u] != v)``          ``return` `true``;``      ``}``    ``}``    ``return` `false``;``  ``}`  `  ``static` `boolean` `isCyclicDisconntected(``                       ``ArrayList adj[], ``int` `V)``  ``{` `    ``// Mark all the vertices as not visited``    ``boolean` `visited[] = ``new` `boolean``[V];``    ``Arrays.fill(visited,``false``);` `    ``for` `(``int` `i = ``0``; i < V; i++)``      ``if` `(!visited[i] &&``          ``isCyclicConntected(adj, i, V, visited))``        ``return` `true``;``    ``return` `false``;``  ``}``}` `// This code is contributed by mayukh Sengupta`

## Python3

 `# Python3 program to detect cycle in``# an undirected graph using BFS.``from` `collections ``import` `deque` `def` `addEdge(adj: ``list``, u, v):``    ``adj[u].append(v)``    ``adj[v].append(u)` `def` `isCyclicConnected(adj: ``list``, s, V,``                      ``visited: ``list``):` `    ``# Set parent vertex for every vertex as -1.``    ``parent ``=` `[``-``1``] ``*` `V` `    ``# Create a queue for BFS``    ``q ``=` `deque()` `    ``# Mark the current node as``    ``# visited and enqueue it``    ``visited[s] ``=` `True``    ``q.append(s)` `    ``while` `q !``=` `[]:` `        ``# Dequeue a vertex from queue and print it``        ``u ``=` `q.pop()` `        ``# Get all adjacent vertices of the dequeued``        ``# vertex u. If a adjacent has not been visited,``        ``# then mark it visited and enqueue it. We also``        ``# mark parent so that parent is not considered``        ``# for cycle.``        ``for` `v ``in` `adj[u]:``            ``if` `not` `visited[v]:``                ``visited[v] ``=` `True``                ``q.append(v)``                ``parent[v] ``=` `u``            ``elif` `parent[u] !``=` `v:``                ``return` `True` `    ``return` `False` `def` `isCyclicDisconnected(adj: ``list``, V):` `    ``# Mark all the vertices as not visited``    ``visited ``=` `[``False``] ``*` `V` `    ``for` `i ``in` `range``(V):``        ``if` `not` `visited[i] ``and` `\``               ``isCyclicConnected(adj, i, V, visited):``            ``return` `True``    ``return` `False` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``V ``=` `4``    ``adj ``=` `[[] ``for` `i ``in` `range``(V)]``    ``addEdge(adj, ``0``, ``1``)``    ``addEdge(adj, ``1``, ``2``)``    ``addEdge(adj, ``2``, ``0``)``    ``addEdge(adj, ``2``, ``3``)` `    ``if` `isCyclicDisconnected(adj, V):``        ``print``(``"Yes"``)``    ``else``:``        ``print``(``"No"``)` `# This code is contributed by``# sanjeev2552`

## C#

 `// A C# program to detect cycle in``// an undirected graph using BFS.``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``    ``public` `static` `void` `Main(String []arg)``    ``{``        ``int` `V = 4;``        ``List<``int``> []adj = ``new` `List<``int``>[V];``        ``for` `(``int` `i = 0; i < 4; i++)``        ``{``            ``adj[i] = ``new` `List<``int``>();``        ``}` `        ``addEdge(adj, 0, 1);``        ``addEdge(adj, 1, 2);``        ``addEdge(adj, 2, 0);``        ``addEdge(adj, 2, 3);` `        ``if` `(isCyclicDisconntected(adj, V))``        ``{``            ``Console.WriteLine(``"Yes"``);``        ``}``        ``else``        ``{``            ``Console.WriteLine(``"No"``);``        ``}``    ``}` `    ``static` `void` `addEdge(List<``int``> []adj, ``int` `u, ``int` `v)``    ``{``        ``adj[u].Add(v);``        ``adj[v].Add(u);``    ``}` `    ``static` `bool` `isCyclicConntected(List<``int``> []adj, ``int` `s,``                                    ``int` `V, ``bool` `[]visited)``    ``{` `        ``// Set parent vertex for every vertex as -1.``        ``int` `[]parent = ``new` `int``[V];``        ``for` `(``int` `i = 0; i < V; i++)``        ``parent[i] = -1;` `        ``// Create a queue for BFS``        ``Queue<``int``> q = ``new` `Queue<``int``>();` `        ``// Mark the current node as``        ``// visited and enqueue it``        ``visited[s] = ``true``;``        ``q.Enqueue(s);` `        ``while` `(q.Count != 0)``        ``{` `            ``// Dequeue a vertex from``            ``// queue and print it``            ``int` `u = q.Dequeue();` `            ``// Get all adjacent vertices``            ``// of the dequeued vertex u.``            ``// If a adjacent has not been``            ``// visited, then mark it visited``            ``// and enqueue it. We also mark parent``            ``// so that parent is not considered``            ``// for cycle.``            ``for` `(``int` `i = 0; i < adj[u].Count; i++)``            ``{``                ``int` `v = adj[u][i];``                ``if` `(!visited[v])``                ``{``                    ``visited[v] = ``true``;``                    ``q.Enqueue(v);``                    ``parent[v] = u;``                ``}``                ``else` `if` `(parent[u] != v)``                ``{``                    ``return` `true``;``                ``}``            ``}``        ``}``        ``return` `false``;``    ``}` `    ``static` `bool` `isCyclicDisconntected(List<``int``> []adj, ``int` `V)``    ``{` `        ``// Mark all the vertices as not visited``        ``bool` `[]visited = ``new` `bool``[V];` `        ``for` `(``int` `i = 0; i < V; i++)``        ``{``            ``if` `(!visited[i] &&``                ``isCyclicConntected(adj, i, V, visited))``            ``{``                ``return` `true``;``            ``}``        ``}``        ``return` `false``;``    ``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output:

`Yes`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up