Program to count Number of connected components in an undirected graph - GeeksforGeeks

11 Apr, 2022
Given an undirected graph g, the task is to print the number of connected components in the graph.
Examples:  
Input:  
Output: 3 There are three connected components: 1 – 5, 0 – 2 – 4 and 3 
Approach: 
DFS visit all the connected vertices of the given vertex.
When iterating over all vertices, whenever we see unvisited node, it is because it was not visited by DFS done on vertices so far.
That means it is not connected to any previous nodes visited so far i.e it was not part of previous components.
Hence this node belongs to new component.
This means, before visiting this node, we just finished visiting all nodes previous component and that component is now complete.
So we need to increment component counter as we completed a component.
The idea is to use a variable count to store the number of connected components and do the following steps:
Initialize all vertices as unvisited.For all the vertices check if a vertex has not been visited, then perform DFS on that vertex and increment the variable count by 1.
Below is the implementation of the above approach: 
C++
Java
Python3
Javascript
// C++ program for above approach#include <bits/stdc++.h>using namespace std; // Graph class represents a undirected graph// using adjacency list representationclass Graph {    // No. of vertices    int V;     // Pointer to an array containing adjacency lists    list<int>* adj;     // A function used by DFS    void DFSUtil(int v, bool visited[]); public:    // Constructor    Graph(int V);     void addEdge(int v, int w);    int NumberOfconnectedComponents();}; // Function to return the number of// connected components in an undirected graphint Graph::NumberOfconnectedComponents(){     // Mark all the vertices as not visited    bool* visited = new bool[V];     // To store the number of connected components    int count = 0;    for (int v = 0; v < V; v++)        visited[v] = false;     for (int v = 0; v < V; v++) {        if (visited[v] == false) {            DFSUtil(v, visited);            count += 1;        }    }     return count;} void Graph::DFSUtil(int v, bool visited[]){     // Mark the current node as visited    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);} Graph::Graph(int V){    this->V = V;    adj = new list<int>[V];} // Add an undirected edgevoid Graph::addEdge(int v, int w){    adj[v].push_back(w);    adj[w].push_back(v);} // Driver codeint main(){    Graph g(5);    g.addEdge(1, 0);    g.addEdge(2, 3);    g.addEdge(3, 4);     cout << g.NumberOfconnectedComponents();     return 0;}
import java.util.*;class Graph {    private int V; // No. of vertices in graph.     private LinkedList<Integer>[] adj; // Adjacency List                                       // representation     ArrayList<ArrayList<Integer> > components        = new ArrayList<>();     @SuppressWarnings("unchecked") Graph(int v)    {        V = v;        adj = new LinkedList[v];         for (int i = 0; i < v; i++)            adj[i] = new LinkedList();    }     void addEdge(int u, int w)    {        adj[u].add(w);        adj[w].add(u); // Undirected Graph.    }     void DFSUtil(int v, boolean[] visited,                 ArrayList<Integer> al)    {        visited[v] = true;        al.add(v);        System.out.print(v + " ");        Iterator<Integer> it = adj[v].iterator();         while (it.hasNext()) {            int n = it.next();            if (!visited[n])                DFSUtil(n, visited, al);        }    }     void DFS()    {        boolean[] visited = new boolean[V];         for (int i = 0; i < V; i++) {            ArrayList<Integer> al = new ArrayList<>();            if (!visited[i]) {                DFSUtil(i, visited, al);                components.add(al);            }        }    }     int ConnecetedComponents() { return components.size(); }}public class Main {    public static void main(String[] args)    {        Graph g = new Graph(6);         g.addEdge(1, 5);        g.addEdge(0, 2);        g.addEdge(2, 4);        System.out.println("Graph DFS:");        g.DFS();        System.out.println(            "\nNumber of Conneceted Components: "            + g.ConnecetedComponents());    }}// Code contributed by Madhav Chittlangia.
# Python3 program for above approach # Graph class represents a undirected graph# using adjacency list representationclass Graph:         def __init__(self, V):         # No. of vertices        self.V = V         # Pointer to an array containing        # adjacency lists        self.adj = [[] for i in range(self.V)]     # Function to return the number of    # connected components in an undirected graph    def NumberOfconnectedComponents(self):                 # Mark all the vertices as not visited        visited = [False for i in range(self.V)]                 # To store the number of connected        # components        count = 0                 for v in range(self.V):            if (visited[v] == False):                self.DFSUtil(v, visited)                count += 1                         return count             def DFSUtil(self, v, visited):         # Mark the current node as visited        visited[v] = True         # Recur for all the vertices        # adjacent to this vertex        for i in self.adj[v]:            if (not visited[i]):                self.DFSUtil(i, visited)                     # Add an undirected edge    def addEdge(self, v, w):                 self.adj[v].append(w)        self.adj[w].append(v)         # Driver code       if __name__=='__main__':         g = Graph(5)    g.addEdge(1, 0)    g.addEdge(2, 3)    g.addEdge(3, 4)         print(g.NumberOfconnectedComponents()) # This code is contributed by rutvik_56
<script> // JavaScript program for above approach // Graph class represents a undirected graph// using adjacency list representationclass Graph{         constructor(V){         // No. of vertices        this.V = V         // Pointer to an array containing        // adjacency lists        this.adj = new Array(this.V);        for(let i=0;i<V;i++){            this.adj[i] = new Array()        }    }     // Function to return the number of    // connected components in an undirected graph    NumberOfconnectedComponents(){                 // Mark all the vertices as not visited        let visited = new Array(this.V).fill(false);                 // To store the number of connected        // components        let count = 0                 for(let v=0;v<this.V;v++){            if (visited[v] == false){                this.DFSUtil(v, visited)                count += 1            }        }                         return count    }     DFSUtil(v, visited){         // Mark the current node as visited        visited[v] = true;         // Recur for all the vertices        // adjacent to this vertex        for(let i of this.adj[v]){            if (visited[i] == false){                this.DFSUtil(i, visited)            }        }           }                     // Add an undirected edge    addEdge(v, w){        this.adj[v].push(w)        this.adj[w].push(v)    }     }         // Driver code   let g = new Graph(5)g.addEdge(1, 0)g.addEdge(2, 3)g.addEdge(3, 4) document.write(g.NumberOfconnectedComponents(),"</br>") // This code is contributed by shinjanpatra</script>
2
Complexity Analysis:
Time complexity: O(V + E), where V is the number of vertices and E is the number of edges in the graph.Space Complexity: O(V), since an extra visited array of size V is required.
alfiskaria
rutvik_56
prashantkumar dhotre
ruhelaa48
madhavchitlangia
saurabh1990aror
shinjanpatra
prophet1999
DFS
C++ Programs
Data Structures
Graph
Data Structures
DFS
Graph
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
CSV file management using C++
Shallow Copy and Deep Copy in C++
cin in C++
Passing a function as a parameter in C++
Generics in C++
SDE SHEET - A Complete Guide for SDE Preparation
Top 50 Array Coding Problems for Interviews
DSA Sheet by Love Babbar
Doubly Linked List | Set 1 (Introduction and Insertion)
Implementing a Linked List in Java using Class