Connected Components in an undirected graph
Given an undirected graph, print all connected components line by line. For example consider the following graph.
We strongly recommend to minimize your browser and try this yourself first.
We have discussed algorithms for finding strongly connected components in directed graphs in following posts.
Kosaraju’s algorithm for strongly connected components.
Tarjan’s Algorithm to find Strongly Connected Components
Finding connected components for an undirected graph is an easier task. We simple need to do either BFS or DFS starting from every unvisited vertex, and we get all strongly connected components. Below are steps based on DFS.
1) Initialize all vertices as not visited. 2) Do following for every vertex 'v'. (a) If 'v' is not visited before, call DFSUtil(v) (b) Print new line character DFSUtil(v) 1) Mark 'v' as visited. 2) Print 'v' 3) Do following for every adjacent 'u' of 'v'. If 'u' is not visited, then recursively call DFSUtil(u)
Below is the implementation of above algorithm.
C++
// C++ program to print connected components in // an undirected graph #include<iostream> #include <list> using namespace std; // Graph class represents a undirected graph // using adjacency list representation class Graph { int V; // No. of vertices // Pointer to an array containing adjacency lists list< int > *adj; // A function used by DFS void DFSUtil( int v, bool visited[]); public : Graph( int V); // Constructor void addEdge( int v, int w); void connectedComponents(); }; // Method to print connected components in an // undirected graph void Graph::connectedComponents() { // Mark all the vertices as not visited bool *visited = new bool [V]; for ( int v = 0; v < V; v++) visited[v] = false ; for ( int v=0; v<V; v++) { if (visited[v] == false ) { // print all reachable vertices // from v DFSUtil(v, visited); cout << "\n" ; } } } 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; for (i = adj[v].begin(); i != adj[v].end(); ++i) if (!visited[*i]) DFSUtil(*i, visited); } Graph::Graph( int V) { this ->V = V; adj = new list< int >[V]; } // method to add an undirected edge void Graph::addEdge( int v, int w) { adj[v].push_back(w); adj[w].push_back(v); } // Drive program to test above int main() { // Create a graph given in the above diagram Graph g(5); // 5 vertices numbered from 0 to 4 g.addEdge(1, 0); g.addEdge(2, 3); g.addEdge(3, 4); cout << "Following are connected components \n" ; g.connectedComponents(); return 0; } |
Java
// Java program to print connected components in // an undirected graph import java.util.LinkedList; class Graph { // A user define class to represent a graph. // A graph is an array of adjacency lists. // Size of array will be V (number of vertices // in graph) int V; LinkedList<Integer>[] adjListArray; // constructor Graph( int V) { this .V = V; // define the size of array as // number of vertices adjListArray = new LinkedList[V]; // Create a new list for each vertex // such that adjacent nodes can be stored for ( int i = 0 ; i < V ; i++){ adjListArray[i] = new LinkedList<Integer>(); } } // Adds an edge to an undirected graph void addEdge( int src, int dest) { // Add an edge from src to dest. adjListArray[src].add(dest); // Since graph is undirected, add an edge from dest // to src also adjListArray[dest].add(src); } void DFSUtil( int v, boolean [] visited) { // Mark the current node as visited and print it visited[v] = true ; System.out.print(v+ " " ); // Recur for all the vertices // adjacent to this vertex for ( int x : adjListArray[v]) { if (!visited[x]) DFSUtil(x,visited); } } void connectedComponents() { // Mark all the vertices as not visited boolean [] visited = new boolean [V]; for ( int v = 0 ; v < V; ++v) { if (!visited[v]) { // print all reachable vertices // from v DFSUtil(v,visited); System.out.println(); } } } // Driver program to test above public static void main(String[] args){ // Create a graph given in the above diagram Graph g = new Graph( 5 ); // 5 vertices numbered from 0 to 4 g.addEdge( 1 , 0 ); g.addEdge( 2 , 3 ); g.addEdge( 3 , 4 ); System.out.println( "Following are connected components" ); g.connectedComponents(); } } |
Python 3
# Python program to print connected # components in an undirected graph class Graph: # init function to declare class variables def __init__( self ,V): self .V = V self .adj = [[] for i in range (V)] def DFSUtil( self , temp, v, visited): # Mark the current vertex as visited visited[v] = True # Store the vertex to list temp.append(v) # Repeat for all vertices adjacent # to this vertex v for i in self .adj[v]: if visited[i] = = False : # Update the list temp = self .DFSUtil(temp, i, visited) return temp # method to add an undirected edge def addEdge( self , v, w): self .adj[v].append(w) self .adj[w].append(v) # Method to retrieve connected components # in an undirected graph def connectedComponents( self ): visited = [] cc = [] for i in range ( self .V): visited.append( False ) for v in range ( self .V): if visited[v] = = False : temp = [] cc.append( self .DFSUtil(temp, v, visited)) return cc # Driver Code if __name__ = = "__main__" : # Create a graph given in the above diagram # 5 vertices numbered from 0 to 4 g = Graph( 5 ); g.addEdge( 1 , 0 ) g.addEdge( 2 , 3 ) g.addEdge( 3 , 4 ) cc = g.connectedComponents() print ( "Following are connected components" ) print (cc) # This code is contributed by Abhishek Valsan |
C#
// C# program to print connected components in // an undirected graph using System; using System.Collections.Generic; public class Graph { // A user define class to represent a graph. // A graph is an array of adjacency lists. // Size of array will be V (number of vertices // in graph) int V; List< int >[] adjListArray; // constructor Graph( int V) { this .V = V; // define the size of array as // number of vertices adjListArray = new List< int >[V]; // Create a new list for each vertex // such that adjacent nodes can be stored for ( int i = 0; i < V ; i++) { adjListArray[i] = new List< int >(); } } // Adds an edge to an undirected graph void addEdge( int src, int dest) { // Add an edge from src to dest. adjListArray[src].Add(dest); // Since graph is undirected, add an edge from dest // to src also adjListArray[dest].Add(src); } void DFSUtil( int v, bool [] visited) { // Mark the current node as visited and print it visited[v] = true ; Console.Write(v+ " " ); // Recur for all the vertices // adjacent to this vertex foreach ( int x in adjListArray[v]) { if (!visited[x]) DFSUtil(x,visited); } } void connectedComponents() { // Mark all the vertices as not visited bool [] visited = new bool [V]; for ( int v = 0; v < V; ++v) { if (!visited[v]) { // print all reachable vertices // from v DFSUtil(v,visited); Console.WriteLine(); } } } // Driver code public static void Main(String[] args) { // Create a graph given in the above diagram Graph g = new Graph(5); // 5 vertices numbered from 0 to 4 g.addEdge(1, 0); g.addEdge(2, 3); g.addEdge(3, 4); Console.WriteLine( "Following are connected components" ); g.connectedComponents(); } } // This code has been contributed by 29AjayKumar |
Output:
0 1 2 3 4
Time complexity of above solution is O(V + E) as it does simple DFS for given graph.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
Recommended Posts:
- Sum of the minimum elements in all connected components of an undirected graph
- Clone an undirected graph with multiple connected components
- Program to count Number of connected components in an undirected graph
- Maximum number of edges among all connected components of an undirected graph
- Cycles of length n in an undirected and connected graph
- Number of single cycle components in an undirected graph
- Kth largest node among all directly connected nodes to the given node in an undirected graph
- Strongly Connected Components
- Number of connected components in a 2-D matrix of strings
- Tarjan's Algorithm to find Strongly Connected Components
- Convert the undirected graph into directed graph such that there is no path of length greater than 1
- Check if a directed graph is connected or not
- Clone an Undirected Graph
- Check if a graph is strongly connected | Set 1 (Kosaraju using DFS)
- All vertex pairs connected with exactly k edges in a graph