Connected Components in an Undirected Graph
Last Updated : 16 Apr, 2025
Given an undirected graph, the task is to return all the connected components in any order.
Examples:
Input: Consider the following graph
Example of an undirected graphOutput: [[0, 1, 2], [3, 4]]
Explanation: There are 2 different connected components.
They are {0, 1, 2} and {3, 4}.
Approach 1: Using Depth first search (DFS)
The main idea is to Use DFS to explore each node. If a node hasn’t been visited yet, start a DFS from it. All nodes reached during this traversal belong to the same connected component.
Step by Step implementation:
- Create an adjacency list from the edge list.
- Initialize a visited array and mark every node as unvisited initially.
- Start from any unvisited node and perform a DFS. All nodes reachable from this node will belong to the same connected component.
- Iterate over all nodes, and for each unvisited node, perform a DFS and store the result.
C++ #include <iostream> #include <vector> using namespace std; // Function to build the adjacency list from edge list vector<vector<int>> buildGraph(int V, vector<vector<int>>& edges) { vector<vector<int>> adj(V); // Populate the adjacency list from the edge list for (auto edge : edges) { int u = edge[0]; int v = edge[1]; // Add both directions since the graph is undirected adj[u].push_back(v); adj[v].push_back(u); } return adj; } // Function to perform DFS and collect all // nodes in the current connected component void dfs(int node, vector<vector<int>>& adj, vector<bool>& vis, vector<int>& component) { // Mark the current node as visited vis[node] = true; // Add the node to the current component component.push_back(node); // Traverse all unvisited neighbors for (int neighbor : adj[node]) { if (!vis[neighbor]) { dfs(neighbor, adj, vis, component); } } } // Function to find all connected components // in an undirected graph vector<vector<int>> getComponents(int V, vector<vector<int>>& edges) { // Create the graph using the adjacency list vector<vector<int>> adj = buildGraph(V, edges); // Initialize a visited array to keep track of visited nodes vector<bool> vis(V, false); // This will store all the connected components vector<vector<int>> res; // Iterate through all nodes for (int i = 0; i < V; ++i) { // If the node has not been visited, it's a new component if (!vis[i]) { vector<int> component; // Perform DFS to collect all nodes in this component dfs(i, adj, vis, component); // Add the component to the result list res.push_back(component); } } // Return the list of all connected components return res; } int main() { // Number of nodes in the graph int V = 5; // Edge list representing the undirected graph as vector of vectors vector<vector<int>> edges = {{0, 1}, {1, 2}, {3, 4}}; // Get all connected components using the countComponents function vector<vector<int>> res = getComponents(V, edges); for (const auto& comp : res) { for (int node : comp) { cout << node << " "; } cout << "\n"; } return 0; } import java.util.*; class GfG { // Function to build the adjacency list from edge list static ArrayList<ArrayList<Integer>> buildGraph(int V, int[][] edges) { ArrayList<ArrayList<Integer>> adj = new ArrayList<>(); // Initialize the adjacency list with empty lists for (int i = 0; i < V; i++) { adj.add(new ArrayList<>()); } // Populate the adjacency list from the edge list for (int[] edge : edges) { int u = edge[0]; int v = edge[1]; // Add both directions since the graph is undirected adj.get(u).add(v); adj.get(v).add(u); } return adj; } // Function to perform DFS and collect all // nodes in the current connected component static void dfs(int node, ArrayList<ArrayList<Integer>> adj, boolean[] vis, ArrayList<Integer> component) { // Mark the current node as visited vis[node] = true; // Add the node to the current component component.add(node); // Traverse all unvisited neighbors for (int neighbor : adj.get(node)) { if (!vis[neighbor]) { dfs(neighbor, adj, vis, component); } } } // Function to find all connected components // in an undirected graph static ArrayList<ArrayList<Integer>> getComponents(int V, int[][] edges) { // Create the graph using the adjacency list ArrayList<ArrayList<Integer>> adj = buildGraph(V, edges); // Initialize a visited array to keep track of visited nodes boolean[] vis = new boolean[V]; // This will store all the connected components ArrayList<ArrayList<Integer>> res = new ArrayList<>(); // Iterate through all nodes for (int i = 0; i < V; i++) { // If the node has not been visited, it's a new component if (!vis[i]) { ArrayList<Integer> component = new ArrayList<>(); // Perform DFS to collect all nodes in this component dfs(i, adj, vis, component); // Add the component to the result list res.add(component); } } return res; } public static void main(String[] args) { // Number of nodes in the graph int V = 5; // Edge list representing the undirected graph as 2D array int[][] edges = { {0, 1}, {1, 2}, {3, 4} }; // Get all connected components using the getComponents function ArrayList<ArrayList<Integer>> res = getComponents(V, edges); // Print each connected component for (ArrayList<Integer> comp : res) { for (int node : comp) { System.out.print(node + " "); } System.out.println(); } } } def buildGraph(n, edges): adj = [[] for _ in range(V)] # Populate the adjacency list from the edge list for edge in edges: u, v = edge[0], edge[1] # Add both directions since the graph is undirected adj[u].append(v) adj[v].append(u) return adj def dfs(node, adj, vis, component): # Mark the current node as visited vis[node] = True # Add the node to the current component component.append(node) # Traverse all unvisited neighbors for neighbor in adj[node]: if not vis[neighbor]: dfs(neighbor, adj, vis, component) def getComponents(V, edges): # Create the graph using the adjacency list adj = buildGraph(V, edges) # Initialize a visited array to keep track of visited nodes vis = [False] * V # This will store all the connected components res = [] # Iterate through all nodes for i in range(V): # If the node has not been visited, it's a new component if not vis[i]: component = [] # Perform DFS to collect all nodes in this component dfs(i, adj, vis, component) # Add the component to the result list res.append(component) return res if __name__ == "__main__": # Number of nodes in the graph V = 5 # Edge list representing the undirected graph as 2D array edges = [ [0, 1], [1, 2], [3, 4] ] # Get all connected components using the countComponents function res = getComponents(V, edges) # Print each connected component for comp in res: print(" ".join(map(str, comp))) using System; using System.Collections.Generic; class GfG { // Function to build the adjacency list from edge list static List<List<int>> buildGraph(int V, int[,] edges) { List<List<int>> adj = new List<List<int>>(); // Initialize the adjacency list with empty lists for each node for (int i = 0; i < V; i++) { adj.Add(new List<int>()); } // Populate the adjacency list from the edge list for (int i = 0; i < edges.GetLength(0); i++) { int u = edges[i, 0]; int v = edges[i, 1]; // Add both directions since the graph is undirected adj[u].Add(v); adj[v].Add(u); } return adj; } // Function to perform DFS and collect all // nodes in the current connected component static void dfs(int node, List<List<int>> adj, bool[] vis, List<int> component) { // Mark the current node as visited vis[node] = true; // Add the node to the current component component.Add(node); // Traverse all unvisited neighbors foreach (int neighbor in adj[node]) { if (!vis[neighbor]) { dfs(neighbor, adj, vis, component); } } } // Function to find all connected components in an undirected graph public static List<List<int>> getComponents(int V, int[,] edges) { // Create the graph using the adjacency list List<List<int>> adj = buildGraph(V, edges); // Initialize a visited array to keep track of visited nodes bool[] vis = new bool[V]; // This will store all the connected components List<List<int>> res = new List<List<int>>(); // Iterate through all nodes for (int i = 0; i < V; i++) { // If the node has not been visited, it's a new component if (!vis[i]) { List<int> component = new List<int>(); // Perform DFS to collect all nodes in this component dfs(i, adj, vis, component); // Add the component to the result list res.Add(component); } } return res; } static void Main() { // Number of nodes in the graph int V = 5; // Edge list representing the undirected graph as 2D array int[,] edges = { {0, 1}, {1, 2}, {3, 4} }; // Get all connected components using the countComponents function List<List<int>> res = getComponents(V, edges); // Print each connected component foreach (var comp in res) { foreach (int node in comp) { Console.Write(node + " "); } Console.WriteLine(); } } } // Function to build the adjacency list from the edge list function buildGraph(V, edges) { let adj = Array.from({ length: V }, () => []); // Populate the adjacency list from the edge list for (let i = 0; i < edges.length; i++) { let u = edges[i][0]; let v = edges[i][1]; // Add both directions since the graph is undirected adj[u].push(v); adj[v].push(u); } return adj; } // Function to perform DFS and collect // all nodes in the current connected component function dfs(node, adj, vis, component) { // Mark the current node as visited vis[node] = true; // Add the node to the current component component.push(node); // Traverse all unvisited neighbors for (let neighbor of adj[node]) { if (!vis[neighbor]) { dfs(neighbor, adj, vis, component); } } } // Function to find all connected components in an undirected graph function getComponents(V, edges) { // Create the graph using the adjacency list let adj = buildGraph(V, edges); // Initialize a visited array to keep track of visited nodes let vis = new Array(V).fill(false); // This will store all the connected components let res = []; // Iterate through all nodes for (let i = 0; i < V; i++) { // If the node has not been visited, it's a new component if (!vis[i]) { let component = []; // Perform DFS to collect all nodes in this component dfs(i, adj, vis, component); // Add the component to the result list res.push(component); } } return res; } // Driver Code let V = 5; // Edge list representing the undirected graph as 2D array let edges = [ [0, 1], [1, 2], [3, 4] ]; // Get all connected components using the countComponents function let components = getComponents(V, edges); // Print each connected component components.forEach(component => { console.log(component.join(" ")); }); Time Complexity: O(V + E) where V is the number of vertices and E is the number of edges.
Auxiliary Space: O(V + E)
The idea to solve the problem using DSU (Disjoint Set Union) is to initially declare all the nodes as individual subsets and then visit them. When a new unvisited node is encountered, unite it with the underlying subset. In this manner, a single component will be visited in each traversal
Step by Step implementation:
- Declare an array arr[] of size V, where V is the total number of nodes in the graph.
- The value at each index i of the array represents the parent of the node i.
- At the beginning, each node is its own parent. This is the base state where each node is considered an individual subset.
- Perform Union Operation:
- When nodes are united, change the parent of one node to the other, ensuring that the sets are merged properly.
- Each time two nodes are united, their parents are updated accordingly to reflect the new structure of the set.
- Traverse the Nodes:
- Go through each node from 0 to V-1.
- If a node is its own parent (i.e., it is a representative of a set), perform the DSU (find and union) operation starting from that node.
- Store the result of every component and return it.
C++ #include <bits/stdc++.h> using namespace std; // Function to find the root parent of a node with path compression int findParent(vector<int>& parent, int x) { if (parent[x] == x) return x; return parent[x] = findParent(parent, parent[x]); } // Function to unite two subsets void unionSets(vector<int>& parent, int x, int y) { int px = findParent(parent, x); int py = findParent(parent, y); if (px != py) { parent[px] = py; } } // Function to find all connected components using DSU vector<vector<int>> getComponents(int V, vector<vector<int>>& edges) { // Initialize each node as its own parent vector<int> parent(V); for (int i = 0; i < V; i++) { parent[i] = i; } // Union sets using edge list for (auto& edge : edges) { unionSets(parent, edge[0], edge[1]); } // Apply path compression for all nodes for (int i = 0; i < V; i++) { parent[i] = findParent(parent, i); } // Group nodes by their root parent unordered_map<int, vector<int>> resMap; for (int i = 0; i < V; i++) { resMap[parent[i]].push_back(i); } // Collect all components into a result vector vector<vector<int>> res; for (auto& entry : resMap) { res.push_back(entry.second); } return res; } int main() { int V = 5; // Edge list as vector of vectors vector<vector<int>> edges = { {0, 1}, {1, 2}, {3, 4} }; // Find connected components using DSU vector<vector<int>> res = getComponents(V, edges); for (const auto& comp : res) { for (int node : comp) { cout << node << " "; } cout << endl; } return 0; } import java.util.*; class GfG { // Function to find the root parent of a node with path compression static int findParent(ArrayList<Integer> parent, int x) { if (parent.get(x) == x) return x; parent.set(x, findParent(parent, parent.get(x))); return parent.get(x); } // Function to unite two subsets static void unionSets(ArrayList<Integer> parent, int x, int y) { int px = findParent(parent, x); int py = findParent(parent, y); if (px != py) { parent.set(px, py); } } // Function to find all connected components using DSU static ArrayList<ArrayList<Integer>> getComponents(int V, int[][] edges) { // Initialize each node as its own parent ArrayList<Integer> parent = new ArrayList<>(); for (int i = 0; i < V; i++) { parent.add(i); } // Union sets using edge list for (int[] edge : edges) { unionSets(parent, edge[0], edge[1]); } // Apply path compression for all nodes for (int i = 0; i < V; i++) { parent.set(i, findParent(parent, i)); } // Group nodes by their root parent Map<Integer, ArrayList<Integer>> resMap = new HashMap<>(); for (int i = 0; i < V; i++) { resMap.putIfAbsent(parent.get(i), new ArrayList<>()); resMap.get(parent.get(i)).add(i); } // Collect all components into a result list ArrayList<ArrayList<Integer>> res = new ArrayList<>(); for (Map.Entry<Integer, ArrayList<Integer>> entry : resMap.entrySet()) { res.add(entry.getValue()); } return res; } public static void main(String[] args) { int V = 5; // Edge list as 2D array int[][] edges = { {0, 1}, {1, 2}, {3, 4} }; // Find connected components using DSU ArrayList<ArrayList<Integer>> res = getComponents(V, edges); // Print the connected components for (ArrayList<Integer> comp : res) { for (int node : comp) { System.out.print(node + " "); } System.out.println(); } } } # Function to find the root parent of a node with path compression def findParent(parent, x): if parent[x] == x: return x # Path compression parent[x] = findParent(parent, parent[x]) return parent[x] # Function to unite two subsets def unionSets(parent, x, y): px = findParent(parent, x) py = findParent(parent, y) if px != py: # Union operation parent[px] = py def getComponents(V, edges): # Initialize each node as its own parent parent = [i for i in range(V)] # Union sets using the edge list for edge in edges: unionSets(parent, edge[0], edge[1]) # Apply path compression for all nodes for i in range(V): parent[i] = findParent(parent, i) # Group nodes by their root parent resMap = {} for i in range(V): root = parent[i] if root not in resMap: resMap[root] = [] resMap[root].append(i) # Collect all components into a result list res = list(resMap.values()) return res if __name__ == "__main__": V = 5 # Edge list as 2D array (list of lists) edges = [ [0, 1], [1, 2], [3, 4] ] # Find connected components using DSU res = getComponents(V, edges) # Print connected components for comp in res: print(" ".join(map(str, comp))) using System; using System.Collections.Generic; class GfG { // Function to find the root parent of a node with path compression public static int findParent(List<int> parent, int x) { if (parent[x] == x) return x; // Path compression parent[x] = findParent(parent, parent[x]); return parent[x]; } // Function to unite two subsets public static void unionSets(List<int> parent, int x, int y) { int px = findParent(parent, x); int py = findParent(parent, y); if (px != py) { // Union operation parent[px] = py; } } // Function to find all connected components using DSU public static List<List<int>> getComponents(int V, int[,] edges) { // Initialize each node as its own parent List<int> parent = new List<int>(V); for (int i = 0; i < V; i++) { parent.Add(i); } // Union sets using the edge list for (int i = 0; i < edges.GetLength(0); i++) { unionSets(parent, edges[i, 0], edges[i, 1]); } // Apply path compression for all nodes for (int i = 0; i < V; i++) { parent[i] = findParent(parent, i); } // Group nodes by their root parent Dictionary<int, List<int>> resMap = new Dictionary<int, List<int>>(); for (int i = 0; i < V; i++) { int root = parent[i]; if (!resMap.ContainsKey(root)) { resMap[root] = new List<int>(); } resMap[root].Add(i); } // Collect all components into a result list List<List<int>> res = new List<List<int>>(); foreach (var entry in resMap) { res.Add(entry.Value); } return res; } static void Main(string[] args) { int V = 5; // Edge list as a 2D array int[,] edges = { {0, 1}, {1, 2}, {3, 4} }; // Find connected components using DSU List<List<int>> res = getComponents(V, edges); // Print connected components foreach (var comp in res) { foreach (int node in comp) { Console.Write(node + " "); } Console.WriteLine(); } } } // Function to find the root parent of a node with path compression function findParent(parent, x) { if (parent[x] === x) return x; // Path compression parent[x] = findParent(parent, parent[x]); return parent[x]; } // Function to unite two subsets function unionSets(parent, x, y) { let px = findParent(parent, x); let py = findParent(parent, y); if (px !== py) { // Union operation parent[px] = py; } } function getComponents(V, edges) { // Initialize each node as its own parent let parent = []; for (let i = 0; i < V; i++) { parent[i] = i; } // Union sets using the edge list for (let i = 0; i < edges.length; i++) { unionSets(parent, edges[i][0], edges[i][1]); } // Apply path compression for all nodes for (let i = 0; i < V; i++) { parent[i] = findParent(parent, i); } // Group nodes by their root parent let resMap = {}; for (let i = 0; i < V; i++) { let root = parent[i]; if (!(root in resMap)) { resMap[root] = []; } resMap[root].push(i); } // Collect all components into a result array let res = []; for (let key in resMap) { res.push(resMap[key]); } return res; } // Driver code let V = 5; // Edge list as 2D array let edges = [ [0, 1], [1, 2], [3, 4] ]; // Find connected components using DSU let res = getComponents(V, edges); // Print connected components for (let i = 0; i < res.length; i++) { console.log(res[i].join(' ')); } Time Complexity: O(V+E)
Auxiliary Space: O(V)
Similar Reads
Depth First Search or DFS for a Graph In Depth First Search (or DFS) for a graph, we traverse all adjacent vertices one by one. When we traverse an adjacent vertex, we completely finish the traversal of all vertices reachable through that adjacent vertex. This is similar to a tree, where we first completely traverse the left subtree and
13 min read
DFS in different language
Iterative Depth First Traversal of Graph Given a directed Graph, the task is to perform Depth First Search of the given graph.Note: Start DFS from node 0, and traverse the nodes in the same order as adjacency list.Note : There can be multiple DFS traversals of a graph according to the order in which we pick adjacent vertices. Here we pick
10 min read
Applications, Advantages and Disadvantages of Depth First Search (DFS) Depth First Search is a widely used algorithm for traversing a graph. Here we have discussed some applications, advantages, and disadvantages of the algorithm. Applications of Depth First Search:1. Detecting cycle in a graph: A graph has a cycle if and only if we see a back edge during DFS. So we ca
4 min read
Difference between BFS and DFS Breadth-First Search (BFS) and Depth-First Search (DFS) are two fundamental algorithms used for traversing or searching graphs and trees. This article covers the basic difference between Breadth-First Search and Depth-First Search.Difference between BFS and DFSParametersBFSDFSStands forBFS stands fo
2 min read
Depth First Search or DFS for disconnected Graph Given a Disconnected Graph, the task is to implement DFS or Depth First Search Algorithm for this Disconnected Graph. Example: Input: Disconnected Graph Output: 0 1 2 3 Algorithm for DFS on Disconnected Graph:In the post for Depth First Search for Graph, only the vertices reachable from a given sour
7 min read
Printing pre and post visited times in DFS of a graph Depth First Search (DFS) marks all the vertices of a graph as visited. So for making DFS useful, some additional information can also be stored. For instance, the order in which the vertices are visited while running DFS. Pre-visit and Post-visit numbers are the extra information that can be stored
8 min read
Tree, Back, Edge and Cross Edges in DFS of Graph Given a directed graph, the task is to identify tree, forward, back and cross edges present in the graph.Note: There can be multiple answers.Example:Input: GraphOutput:Tree Edges: 1->2, 2->4, 4->6, 1->3, 3->5, 5->7, 5->8 Forward Edges: 1->8 Back Edges: 6->2 Cross Edges: 5-
9 min read
Transitive Closure of a Graph using DFS Given a directed graph, find out if a vertex v is reachable from another vertex u for all vertex pairs (u, v) in the given graph. Here reachable means that there is a path from vertex u to v. The reach-ability matrix is called transitive closure of a graph. For example, consider below graph: GraphTr
8 min read
Variations of DFS implementations