Number of Islands BFS and DFS in DSA Javascript - Build from Scratch

Number of Islands BFS and DFS

📖 Scenario: You are working with a map represented as a grid. Each cell in the grid is either land ('1') or water ('0').Your task is to find how many separate islands are on the map. An island is a group of connected lands horizontally or vertically.

🎯 Goal: Build a program that counts the number of islands in the grid using both Breadth-First Search (BFS) and Depth-First Search (DFS) methods.

📋 What You'll Learn

Create a 2D array called grid with exact values representing land and water.

Create a variable called visited to track visited cells.

Implement BFS function called bfs to explore connected lands.

Implement DFS function called dfs to explore connected lands.

Count islands using BFS and DFS separately.

Print the number of islands found by BFS and DFS.

💡 Why This Matters

🌍 Real World

Counting islands in a grid is like finding groups of connected land on a map, useful in geography, image processing, and game development.

💼 Career

Understanding BFS and DFS for grid traversal is important for software engineers working on pathfinding, network analysis, and spatial data problems.

1

Create the grid data structure

Create a 2D array called grid with these exact rows:
['1','1','0','0','0'],
['1','1','0','0','0'],
['0','0','1','0','0'],
['0','0','0','1','1'].

DSA Javascript

# Create the 2D array grid with the exact values
# Your code here

Hint

Use const grid = [ [...], [...], [...], [...] ]; with the exact rows given.

2

Create the visited array

Create a 2D array called visited with the same dimensions as grid, filled with false values.

DSA Javascript

const grid = [
  ['1','1','0','0','0'],
  ['1','1','0','0','0'],
  ['0','0','1','0','0'],
  ['0','0','0','1','1']
];
// Create visited array with false values
// Your code here

Hint

Use a for loop to create each row of visited filled with false.

3

Implement BFS and DFS functions

Implement a function called bfs that takes row and col and marks all connected land cells as visited using Breadth-First Search.
Implement a function called dfs that takes row and col and marks all connected land cells as visited using Depth-First Search.

DSA Javascript

const grid = [
  ['1','1','0','0','0'],
  ['1','1','0','0','0'],
  ['0','0','1','0','0'],
  ['0','0','0','1','1']
];

const visited = [];
for (let i = 0; i < grid.length; i++) {
  visited.push(new Array(grid[0].length).fill(false));
}

// Implement bfs function
// Your code here

// Implement dfs function
// Your code here

Hint

Use a queue for BFS and recursion for DFS. Mark visited cells to avoid repeats.

4

Count islands and print results

Use the bfs function to count islands and store the count in bfsCount.
Reset visited to all false.
Use the dfs function to count islands and store the count in dfsCount.
Print bfsCount and dfsCount separated by a space.

DSA Javascript

const grid = [
  ['1','1','0','0','0'],
  ['1','1','0','0','0'],
  ['0','0','1','0','0'],
  ['0','0','0','1','1']
];

const visited = [];
for (let i = 0; i  0) {
    const [r, c] = queue.shift();
    for (const [dr, dc] of directions) {
      const nr = r + dr;
      const nc = c + dc;
      if (nr >= 0 && nr = 0 && nc = grid.length || col = grid[0].length) return;
  if (grid[row][col] === '0' || visited[row][col]) return;

  visited[row][col] = true;
  dfs(row + 1, col);
  dfs(row - 1, col);
  dfs(row, col + 1);
  dfs(row, col - 1);
}

// Count islands using bfs
// Reset visited
// Count islands using dfs
// Print bfsCount and dfsCount
// Your code here

Hint

Count islands by calling bfs or dfs on unvisited land cells. Reset visited before second count. Print both counts separated by space.

Practice

1. What does the "Number of Islands" problem ask you to find in a grid of '1's and '0's?

easy

A. Count how many groups of connected '1's (islands) are in the grid

B. Find the largest island size in the grid

C. Calculate the total number of '0's in the grid

D. Replace all '1's with '0's in the grid

Solution

1. Step 1: Understand the grid representation

   The grid contains '1's representing land and '0's representing water.

2. Step 2: Identify what an island means

   An island is a group of connected '1's horizontally or vertically.

3. Final Answer:

   Count how many groups of connected '1's (islands) are in the grid -> Option A

4. Quick Check:

   Number of islands = count of connected '1' groups [OK]

Hint: Islands = connected '1's groups, count them [OK]

Common Mistakes:

• Confusing island count with largest island size
• Counting '0's instead of '1's
• Ignoring connectivity rules (only horizontal/vertical)

2. Which of the following is the correct way to start a DFS function in JavaScript for the Number of Islands problem?

easy

A. function dfs(grid, r, c) { if (r < 0 || c < 0) return; }

B. function dfs(grid, r, c) { if (r <= 0 || c <= 0 || r > grid.length || c > grid[0].length) return; }

C. function dfs(grid, r, c) { if (r > grid.length || c > grid[0].length) return; }

D. function dfs(grid, r, c) { if (r < 0 || c < 0 || r >= grid.length || c >= grid[0].length) return; }

Solution

1. Step 1: Check boundary conditions for DFS

   We must stop DFS if row or column is outside grid bounds.

2. Step 2: Write correct boundary check

   Row or column less than 0 or greater or equal to grid size means out of bounds.

3. Final Answer:

   function dfs(grid, r, c) { if (r < 0 || c < 0 || r >= grid.length || c >= grid[0].length) return; } -> Option D

4. Quick Check:

   Boundary check includes all invalid indices [OK]

Hint: Check all out-of-bound indices with < 0 or >= length [OK]

Common Mistakes:

• Using > instead of >= for boundary check
• Missing some boundary conditions
• Using <= 0 which excludes valid index 0

3. What will be the output of the following code snippet for the grid below?

const grid = [ ['1','1','0','0'], ['1','0','0','1'], ['0','0','1','1'], ['0','0','0','0'] ]; function numIslands(grid) { let count = 0; const dfs = (r, c) => { if (r < 0 || c < 0 || r >= grid.length || c >= grid[0].length || grid[r][c] === '0') return; grid[r][c] = '0'; dfs(r + 1, c); dfs(r - 1, c); dfs(r, c + 1); dfs(r, c - 1); }; for (let r = 0; r < grid.length; r++) { for (let c = 0; c < grid[0].length; c++) { if (grid[r][c] === '1') { dfs(r, c); count++; } } } return count; } console.log(numIslands(grid));

medium

A. 1

B. 3

C. 2

D. 4

Solution

1. Step 1: Identify islands in the grid

   Islands are groups of connected '1's. Here, islands are: top-left (3 cells: (0,0),(0,1),(1,0)), single cell at (1,3), and bottom cluster (2 cells: (2,2),(2,3)). Total islands = 3.

2. Step 2: Count islands using DFS

   DFS marks visited '1's as '0'. After visiting each island, count increments. Total islands counted = 3.

3. Final Answer:

   3 -> Option B

4. Quick Check:

   Count connected '1' groups = 3 [OK]

Hint: Count connected '1' groups by marking visited [OK]

Common Mistakes:

• Counting diagonal connections as islands
• Not marking visited cells, causing overcount
• Misreading grid layout

4. The following BFS code for Number of Islands has a bug. What is the bug?

function bfs(grid, r, c) { const queue = [[r, c]]; while (queue.length > 0) { const [row, col] = queue.shift(); if (row < 0 || col < 0 || row >= grid.length || col >= grid[0].length || grid[row][col] === '0') continue; grid[row][col] = '0'; queue.push([row + 1, col]); queue.push([row - 1, col]); queue.push([row, col + 1]); queue.push([row, col - 1]); } }

medium

A. It does not check if a cell is already visited before pushing neighbors

B. It marks visited cells after adding neighbors to queue

C. It uses queue.shift() which is inefficient for large grids

D. It uses recursion instead of iteration

Solution

1. Step 1: Analyze neighbor addition in BFS

   The code adds neighbors to the queue without checking if they are visited or water.

2. Step 2: Identify consequence of missing check

   This causes multiple visits to the same cell, increasing runtime and possible infinite loops.

3. Final Answer:

   It does not check if a cell is already visited before pushing neighbors -> Option A

4. Quick Check:

   Check before enqueueing neighbors to avoid repeats [OK]

Hint: Check visited before enqueueing neighbors in BFS [OK]

Common Mistakes:

• Thinking queue.shift() inefficiency is the bug here
• Marking visited after enqueue instead of before
• Confusing recursion with iteration

5. Given a grid where diagonal connections also count as connected land, how would you modify the DFS to count islands correctly?

hard

A. Ignore diagonal neighbors and count only vertical connections

B. Only check horizontal neighbors (r,c+1) and (r,c-1)

C. Add diagonal neighbors (r+1,c+1), (r+1,c-1), (r-1,c+1), (r-1,c-1) to DFS calls

D. Use BFS instead of DFS without changing neighbors

Solution

1. Step 1: Understand connectivity rules

   Diagonal connections mean neighbors include diagonals, not just up/down/left/right.

2. Step 2: Modify DFS to include diagonal neighbors

   Add DFS calls for (r+1,c+1), (r+1,c-1), (r-1,c+1), (r-1,c-1) along with existing neighbors.

3. Final Answer:

   Add diagonal neighbors (r+1,c+1), (r+1,c-1), (r-1,c+1), (r-1,c-1) to DFS calls -> Option C

4. Quick Check:

   Include diagonal neighbors for diagonal connectivity [OK]

Hint: Add diagonal neighbors to DFS for diagonal island counting [OK]

Common Mistakes:

• Ignoring diagonal neighbors when required
• Switching BFS/DFS without changing neighbor logic
• Counting only horizontal or vertical neighbors