Connected Components - Problem

Given an undirected graph represented as an adjacency list, find all connected components. A connected component is a maximal set of vertices where every vertex is reachable from every other vertex in the set through some path.

Return a 2D array where each inner array contains all the vertices that belong to the same connected component. The components can be returned in any order, and vertices within each component can also be in any order.

Input: graph - adjacency list representation where graph[i] is a list of all vertices connected to vertex i

Output: 2D array of connected components

Input & Output

Example 1 — Basic Connected Components

$ Input: graph = [[1,3],[0,3],[],[0,1]]

› Output: [[0,1,3],[2]]

💡 Note: Vertices 0, 1, and 3 are connected (0↔1, 0↔3, 1↔3), forming one component. Vertex 2 has no connections, forming a separate component.

Example 2 — Single Component

$ Input: graph = [[1],[0,2],[1]]

› Output: [[0,1,2]]

💡 Note: All vertices are connected in a line: 0↔1↔2, so there's only one connected component.

Example 3 — All Isolated

$ Input: graph = [[],[],[]]

› Output: [[0],[1],[2]]

💡 Note: No edges exist, so each vertex forms its own connected component.

Constraints

1 ≤ n ≤ 2000
0 ≤ graph[i].length ≤ n
0 ≤ graph[i][j] ≤ n - 1
graph[i][j] ≠ i
All values in graph[i] are unique

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28

The key insight is to use graph traversal (DFS or BFS) with a visited array to systematically explore each connected component. Best approach is DFS with recursion for simplicity. Time: O(V + E), Space: O(V).

Common Approaches

✓ BFS Approach

⏱️ Time: O(V + E) Space: O(V)

Similar to DFS but uses a queue to explore vertices level by level. For each unvisited vertex, perform BFS to find all vertices in the same connected component.

Brute Force - Naive Component Detection

⏱️ Time: O(V × (V + E)) Space: O(V)

Check every vertex, and for each unvisited vertex, perform an inefficient traversal to find all connected vertices. This approach may revisit vertices multiple times and doesn't use optimal data structures for tracking visited nodes.

Optimized DFS Approach

⏱️ Time: O(V + E) Space: O(V)

Iterate through all vertices, and for each unvisited vertex, perform a complete DFS traversal to identify all vertices in that connected component. Mark vertices as visited during traversal to avoid duplicates.

BFS Approach — Algorithm Steps

Initialize visited array and queue
For each unvisited vertex, start BFS
Add vertex to queue and mark as visited
Process queue: add neighbors of current vertex
Continue until queue is empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Queue Init

Start with unvisited vertex in queue

Level Explore

Process queue and add neighbors level by level

Components

Complete connected components found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

int** solution(int** graph, int* graphSizes, int graphSize, int* returnSize, int** returnColumnSizes) {
    if (graphSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    bool* visited = (bool*)calloc(graphSize, sizeof(bool));
    int** components = (int**)malloc(graphSize * sizeof(int*));
    int* componentSizes = (int*)malloc(graphSize * sizeof(int));
    int componentCount = 0;
    
    for (int i = 0; i < graphSize; i++) {
        if (!visited[i]) {
            int* component = (int*)malloc(graphSize * sizeof(int));
            int componentSize = 0;
            
            int* queue = (int*)malloc(graphSize * sizeof(int));
            int front = 0, rear = 0;
            
            queue[rear++] = i;
            visited[i] = true;
            
            while (front < rear) {
                int vertex = queue[front++];
                component[componentSize++] = vertex;
                
                for (int j = 0; j < graphSizes[vertex]; j++) {
                    int neighbor = graph[vertex][j];
                    if (!visited[neighbor]) {
                        visited[neighbor] = true;
                        queue[rear++] = neighbor;
                    }
                }
            }
            
            // Sort component
            for (int j = 0; j < componentSize - 1; j++) {
                for (int k = j + 1; k < componentSize; k++) {
                    if (component[j] > component[k]) {
                        int temp = component[j];
                        component[j] = component[k];
                        component[k] = temp;
                    }
                }
            }
            
            components[componentCount] = component;
            componentSizes[componentCount] = componentSize;
            componentCount++;
            
            free(queue);
        }
    }
    
    *returnSize = componentCount;
    *returnColumnSizes = componentSizes;
    free(visited);
    
    return components;
}

int main() {
    printf("[[0,1,3],[2]]");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex once and each edge once during BFS traversal

✓ Linear Growth

Space Complexity

O(V)

Visited array plus queue can store up to V vertices

✓ Linear Space

34.5K Views

High Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Connected Components - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler