Skip to content
Related Articles

Related Articles

Improve Article

Program to count Number of connected components in an undirected graph

  • Difficulty Level : Medium
  • Last Updated : 25 Sep, 2021

Given an undirected graph g, the task is to print the number of connected components in the graph.

Examples:  

Input: 
 

Output:
There are three connected components: 
1 – 5, 0 – 2 – 4 and 3 



Approach: 

DFS visits all 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 so far.

That means it is not connected to any previous nodes visited so far i.e it was not part 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 componennt

The idea is to use a variable count to store the number of connected components and do the following steps: 

  1. Initialize all vertices as unvisited.
  2. 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++




// C++ program for above approach
#include <bits/stdc++.h>
using namespace std;
 
// Graph class represents a undirected graph
// using adjacency list representation
class 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 graph
int 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 edge
void Graph::addEdge(int v, int w)
{
    adj[v].push_back(w);
    adj[w].push_back(v);
}
 
// Driver code
int main()
{
    Graph g(5);
    g.addEdge(1, 0);
    g.addEdge(2, 3);
    g.addEdge(3, 4);
 
    cout << g.NumberOfconnectedComponents();
 
    return 0;
}

Java




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




# Python3 program for above approach
 
# Graph class represents a undirected graph
# using adjacency list representation
class 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
Output
2

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
Recommended Articles
Page :