# Program to count Number of connected components in an undirected graph

• Difficulty Level : Medium
• Last Updated : 16 Oct, 2021

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

Examples:

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.

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 component

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 ``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[] adj; ``// Adjacency List``                                       ``// representation` `    ``ArrayList > 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 al)``    ``{``        ``visited[v] = ``true``;``        ``al.add(v);``        ``System.out.print(v + ``" "``);``        ``Iterator 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 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`

My Personal Notes arrow_drop_up