Number of Islands - Practice Coding Problems

Number of Islands - Problem

Imagine you're a cartographer analyzing satellite imagery of an archipelago! You have a 2D grid map where '1' represents land and '0' represents water. Your mission is to count how many separate islands exist in this region.

An island is formed by connecting adjacent land cells ('1's) either horizontally or vertically (diagonal connections don't count). Think of it like walking from one piece of land to another - you can only move up, down, left, or right.

Example: If you see connected land masses, they form a single island. Separate land masses surrounded by water are different islands.

The entire grid is surrounded by water, so any land on the edges is still considered part of an island if connected to other land.

Input & Output

example_1.py — Basic Islands

$ Input: grid = [["1","1","1","1","0"],["1","1","0","1","0"],["1","1","0","0","0"],["0","0","0","0","0"]]

› Output: 1

💡 Note: All the 1's are connected horizontally or vertically, forming one large island surrounded by water.

example_2.py — Multiple Islands

$ Input: grid = [["1","1","0","0","0"],["1","1","0","0","0"],["0","0","1","0","0"],["0","0","0","1","1"]]

› Output: 3

💡 Note: There are three separate islands: one 2x2 island in top-left, one single cell in middle, and one 1x2 island in bottom-right.

example_3.py — Single Cell

$ Input: grid = [["1"]]

› Output: 1

💡 Note: Edge case with just one cell containing land forms exactly one island.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 300
grid[i][j] is '0' or '1'
Grid cells contain only characters '0' and '1'

Visualization

Tap to expand

Understanding the Visualization

Systematic Scan

Scan the map methodically from top-left to bottom-right looking for undiscovered land

Island Discovery

When you spot land ('1'), this could be a new island! Increment your island counter

Complete Exploration

Deploy your drone to explore every connected piece of this island using DFS/BFS

Mark Territory

Mark all explored land as 'visited' (change to '0') so you don't count it again

Continue Search

Resume scanning from where you left off to find the next undiscovered island

Key Takeaway

🎯 Key Insight: By using graph traversal (DFS/BFS), we can explore each connected island completely in one pass, ensuring we count each island exactly once while achieving optimal O(m × n) time complexity.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses graph traversal (DFS or BFS) to explore connected components. When we find an unvisited land cell, we increment our island count and use DFS/BFS to mark the entire connected island as visited. This ensures each island is counted exactly once with O(m × n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ BFS with Queue (Optimal)	O(m × n)	O(min(m, n))	Use BFS with queue to explore islands level by level
Brute Force with DFS	O(m × n)	O(m × n)	Check every cell, use DFS to mark connected land when found

BFS with Queue (Optimal) — Algorithm Steps

Initialize island counter and create a queue
Iterate through each cell in the grid
When we find a '1', increment counter and add to queue
Use BFS to explore all connected cells from queue
Mark visited cells and add new land neighbors to queue
Continue until queue is empty, then resume grid scan

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Island Start

Discover first land cell of new island

Add to Queue

Add starting cell to BFS queue

Explore Level

Process all cells at current level

Add Neighbors

Add adjacent land cells to queue

Complete Island

Continue until entire island is explored

Code -

solution.c — C

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

typedef struct {
    int r, c;
} Point;

typedef struct {
    Point* data;
    int front, rear, size;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (Point*)malloc(sizeof(Point) * capacity);
    q->front = q->rear = 0;
    q->size = capacity;
    return q;
}

void enqueue(Queue* q, Point p) {
    q->data[q->rear] = p;
    q->rear = (q->rear + 1) % q->size;
}

Point dequeue(Queue* q) {
    Point p = q->data[q->front];
    q->front = (q->front + 1) % q->size;
    return p;
}

int isEmpty(Queue* q) {
    return q->front == q->rear;
}

int numIslands(char** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) {
        return 0;
    }
    
    int rows = gridSize;
    int cols = gridColSize[0];
    int islands = 0;
    int directions[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    
    Queue* q = createQueue(rows * cols);
    
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < cols; c++) {
            if (grid[r][c] == '1') {
                islands++;
                
                enqueue(q, (Point){r, c});
                grid[r][c] = '0';
                
                while (!isEmpty(q)) {
                    Point curr = dequeue(q);
                    
                    for (int i = 0; i < 4; i++) {
                        int nr = curr.r + directions[i][0];
                        int nc = curr.c + directions[i][1];
                        
                        if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && grid[nr][nc] == '1') {
                            grid[nr][nc] = '0';
                            enqueue(q, (Point){nr, nc});
                        }
                    }
                }
            }
        }
    }
    
    free(q->data);
    free(q);
    return islands;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Each cell is visited exactly once, either during grid scan or BFS traversal

✓ Linear Growth

Space Complexity

O(min(m, n))

Queue size can be at most min(m,n) in worst case when BFS explores diagonally

⚡ Linearithmic Space

67.8K Views

Very High Frequency

~15 min Avg. Time

2.3K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS with Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler