 GFG App
Open App Browser
Continue

# Detect cycle in an undirected graph using BFS

Given an undirected graph, how to check if there is a cycle in the graph? For example, the following graph has a cycle of 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.

Implementation:

## 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` `isCyclicConnected(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` `isCyclicDisconnected(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` `(isCyclicDisconnected(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` `isCyclicConnected(` `                             ``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` `(isCyclicDisconnected(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` `isCyclicConnected(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 the graph and the graph is represented using an adjacency list. So the time complexity is O(V+E)
Space Complexity: O(V) for visited vector.

My Personal Notes arrow_drop_up