Number of Islands: Cheat Sheet for 2026 Interviews

Number of Islands Quick Reference

Key Concepts at a Glance

• •Core technique: Apply the specific pattern that Number of Islands defines
• •Time complexity: Know the optimal complexity and why it is achievable
• •Space complexity: Understand the tradeoff between time and space
• •Key data structures: Know which structures enable the technique
• •Common variations: Be ready for at least three variations of the base problem
• •Edge cases: Empty input, single element, duplicates, negative values

Python Template

def num_islands(grid):
    count = 0
    for i in range(len(grid)):
        for j in range(len(grid[0])):
            if grid[i][j] == '1':
                dfs(grid, i, j)
                count += 1
    return count

def dfs(grid, i, j):
    if i < 0 or i >= len(grid) or j < 0 or j >= len(grid[0]) or grid[i][j] != '1':
        return
    grid[i][j] = '0'
    dfs(grid, i+1, j); dfs(grid, i-1, j)
    dfs(grid, i, j+1); dfs(grid, i, j-1)

TypeScript Template

function numIslands(grid: string[][]): number {
  let count = 0;
  const dfs = (i: number, j: number) => {
    if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] !== '1') return;
    grid[i][j] = '0';
    dfs(i+1, j); dfs(i-1, j); dfs(i, j+1); dfs(i, j-1);
  };
  for (let i = 0; i < grid.length; i++)
    for (let j = 0; j < grid[0].length; j++)
      if (grid[i][j] === '1') { dfs(i, j); count++; }
  return count;
}

Pattern Signals Cheat Sheet

• •Signal 1: The input has a specific structure that the technique exploits
• •Signal 2: The brute force solution has a known inefficiency that this pattern addresses
• •Signal 3: The problem asks for optimization that matches this pattern's strengths
• •Signal 4: The constraints suggest a time complexity achievable with this technique
• •Signal 5: Similar problems in the same category use this pattern

Complexity Reference Table

• •Brute force: Usually O(n squared) or O(n cubed) for Number of Islands problems
• •Optimized with technique: Typically O(n) or O(n log n)
• •Space for iterative: O(1) extra space if done in-place
• •Space for recursive: O(n) for the call stack in worst case
• •Space for hash-based: O(n) for the auxiliary data structure

Interview Day Checklist

• •Can you explain the technique in one sentence?
• •Can you write the solution from memory in under ten minutes?
• •Can you trace through the algorithm with a small example?
• •Do you know the time and space complexity?
• •Can you name three variations of the base problem?
• •Have you practiced explaining your approach out loud?
• •Are you prepared for follow-up questions about optimization?
• •Do you have a clean code template ready to adapt?

Last-Minute Reminders