Find Number of Island in Java

Finding number of island problem is a standard problem usually asked in top companies coding round interview. The problem is based on the graph theory. In graph theory, we find the number of connected components. In this problem, we have to find the same. So, in this section, we will discuss the island problem statement, algorithm, and Java program to find the number of islands.

Problem Statement

In this problem, an island is nothing but a group of connected one's in Boolean 1D, 2D or multidimensional (n-D) array. In this problem, we have to find the number of islands (group of 1's) in a boolean matrix. Note that 1 denotes land.

The statement can be rewritten as follows.

Given a boolean 2D matrix in which 1's denotes land and 0's denotes water. In this matrix, we have to count the number of islands. An island is a place that is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. Assume all four edges of the grid are all surrounded by water. The following image depicts the same.

In the above image, the blocks that are highlighted with green color (1's) denotes land and the blocks highlighted with yellow color (0's) denotes water. The above matrix has five islands.

The above problem is related to connected component in an undirected graph. So first, we will understand what is connected component.

Connected Components

A connected component is a graph in which each pair of nodes is connect with each other via path(s) and which is connected to no other vertices outside the subgraph. For example, consider the following graph.

Example:

Consider the following matrix.

In the above matrix there is only one group of connected 1's. Hence, it denotes only one island.

Solution to the Problem

There are many solutions to the problem. It can be solved either using DFS or BFS. In this section, we will solve the problem using the DFS with recursive and non-recursive approach.

Using Depth First Search (DFS)

In this approach, we will traverse all the lands (1's) of the matrix one by one. If we found any land untraversed or not visited yet, it means we have to found new islands. Once we visit the island, we will increase the number of islands by 1. Using DFS or BFS, we will mark all the lands which are connected as visited.

Algorithm

Define a Boolean array and set all the values as false.
Define a variable ans and initialize it with 0. In this variable, we will store the final answer.
Traverse over each element of the grid.
Check whether it is land (1's) or not, if land increase the variable ans by one.
After that, start either DFS or BFS traversal for that element.

Java Program to Find Number of Islands

Recursive Approach

In the following Java program, we have maintained an array named visited. It keeps track of the lands that we have already visited. Define and initialize a variable answer that stores the number of islands.

Let's implement the above approach in a Java program.

NumberOfIslands.java

public class NumberOfIslands
{
//function that find the number of islands     
public int findIslands(char[][] matrix) 
{
//finds and stores the length of the matrix or grid    
int h = matrix.length;
if (h == 0)
//if matrix has no elements, returns 0
return 0;
int l = matrix[0].length;
//variable to store result
int result = 0;
//loop iterates over rows
for (int i = 0; i < h; i++) 
{
//loop iterates over columns    
for (int j = 0; j < l; j++) 
{
//
if (matrix[i][j] == '1') 
{
//if the above condition returns true, calls the dfs() function and increments the result
dfs(matrix, i,  j);
result++;
}
}
}
return result;
}
//function performs the depth first search over the matrix
public void dfs(char[][] matrix, int row, int col) 
{
int H = matrix.length;
int L = matrix[0].length;
//returns true if any of the condition returns true
if (row < 0 || col < 0 || row >= H || col >= L || matrix[row][col] != '1')
return;
//marking element as visited
matrix[row][col] = '0'; 
//moves in right direction
dfs(matrix, row+ 1, col); 
//moves in left direction
dfs(matrix, row- 1, col); 
//moves in downward direction
dfs(matrix, row, col + 1); 
//moves in upward direction
dfs(matrix, row, col - 1); 
}
//driver code
public static void main(String args[]) 
{
//creating an instance of teh class    
NumberOfIslands noi = new NumberOfIslands();
//grid in which we have to find number of islands
char[][] islandGrid = new char[][] 
{
                {'1', '1', '0', '0', '0'},
                {'1', '1', '0', '0', '0'},
                {'0', '0', '1', '0', '0'},
                {'0', '0', '0', '1', '1'}};
//prints the result
System.out.println("Number of Islands: " + noi.findIslands(islandGrid));
}
}

Output:

Number of Islands: 3

Using Non-Recursive Approach

NumberOfIslands.java

import java.util.Stack;	
public class NumberOfIslands 
{
//function that find the number of islands         
public int findIslands(char[][] matrix) 
{
//finds and stores the number of rows
int h = matrix.length;
if (h == 0)
//if matrix has no elements, returns 0
return 0;
//finds and store the number of columns in row 0
int l = matrix[0].length;
//stores the number of islands
int result = 0;
//returns true if the same number of columns as the first row
boolean[][] visited = new boolean[matrix.length][matrix[0].length];
//loop for rows
for (int i = 0; i < h; i++) 
{
//loop for columns    
for (int j = 0; j < l; j++) 
{
//set element to false    
visited[i][j] = false;
}
}
//creating stack
Stack<String> stack = new Stack<>();
for (int i = 0; i < h; i++) 
{
for (int j = 0; j < l; j++) 
{
//returns true if both condtions returns true    
if (!visited[i][j] && matrix[i][j] == '1') 
{
//if the above condtion returns true, push the i-th row and the j-th column to the stack    
stack.push(i + "," + j);
//calling the dfs() function
dfs(stack, matrix, visited);
result++;
}
}
}
return result;
}
//function performs the depth first search over the matrix
public void dfs(Stack<String> stack, char[][] matrix, boolean[][] visited) 
{
int H = matrix.length;
int L = matrix[0].length;	
while (stack.empty() == false) 
{
String x = stack.pop();
//casting rows and columns
int row = Integer.parseInt(x.split(",")[0]);
int col = Integer.parseInt(x.split(",")[1]);
if(row<0 || col<0 || row>=H || col>=L || visited[row][col] || matrix[row][col]!='1')
continue;
//marking element as visited
visited[row][col]=true;
//moves in left direction
stack.push(row + "," + (col-1));
//moves in right direction
stack.push(row + "," + (col+1));
//moves in upward direction
stack.push((row-1) + "," + col);
//moves in downward direction
stack.push((row+1) + "," + col); 
} //end of while loop
}
public static void main(String args[]) 
{
//creating an instance of the class    
NumberOfIslands noi = new NumberOfIslands();
//grid in which we have to find number of islands
char[][] island= new char[][] 
{
                {'1', '1', '0', '0', '1'},
                {'1', '0', '0', '1', '0'},
                {'0', '0', '1', '0', '0'},
                {'0', '0', '0', '1', '1'}};
//prints the result
System.out.println("Number of Islands: " + noi.findIslands(island));
}
}

Output:

Number of Islands: 5

Complexity

For the above problem, the time complexity is O(n*m) because we have visited each element of the grid at least once. Here, n is number of rows and m is number of columns, respectively.

The space complexity for the above approach is O(n*m) because we have used a 2D array to store the land whether we have visited or not.

Next TopicBalanced Prime Number in Java

← prev next →