岛屿数量问题的DFS/BFS/并查集解法详解-代码聚汇网

岛屿数量问题的DFS/BFS/并查集解法详解

weixin_31315567·2026-08-07·阅读 24 GEO检测（免费）

岛屿数量DFSBFS

|难度：普通|阅读约 12 分钟

1. 岛屿数量问题的背景与定义

200岛屿数量问题是一个经典的计算机科学算法题目，属于图论和深度优先搜索(DFS)的应用范畴。这个问题在LeetCode等编程题库中被标记为中等难度，编号为200题，因此得名"200岛屿数量"。

问题的标准定义是：给定一个由'1'(陆地)和'0'(水)组成的二维网格，计算网格中岛屿的数量。岛屿被定义为被水包围的、通过水平或垂直方向相邻的陆地连接形成的区域。你可以假设网格的四个边均被水包围。

举个例子：

code复制输入：
[
  ['1','1','0','0','0'],
  ['1','1','0','0','0'],
  ['0','0','1','0','0'],
  ['0','0','0','1','1']
]
输出：3

这个问题看似简单，但包含了几个关键点需要注意：

相邻仅指上下左右四个方向，不包括对角线
网格边界外都是水
需要区分不同的岛屿区域

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 解决岛屿数量问题的核心思路

2.1 深度优先搜索(DFS)方法

DFS是解决这类连通性问题最直观的方法。基本思路是：

遍历整个网格
当遇到'1'时，开始DFS搜索
将访问过的'1'标记为已访问(通常改为'0')
递归搜索上下左右的相邻单元格
完成一个岛屿的搜索后，岛屿计数加1

python复制def numIslands(grid):
    if not grid:
        return 0
    
    count = 0
    for i in range(len(grid)):
        for j in range(len(grid[0])):
            if grid[i][j] == '1':
                self.dfs(grid, i, j)
                count += 1
    return count

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

2.2 广度优先搜索(BFS)方法

BFS是另一种可行的解决方案，使用队列来实现：

python复制from collections import deque

def numIslands(grid):
    if not grid:
        return 0
    
    count = 0
    rows, cols = len(grid), len(grid[0])
    
    for i in range(rows):
        for j in range(cols):
            if grid[i][j] == '1':
                count += 1
                queue = deque([(i,j)])
                grid[i][j] = '0'
                
                while queue:
                    x, y = queue.popleft()
                    for dx, dy in [(1,0), (-1,0), (0,1), (0,-1)]:
                        nx, ny = x + dx, y + dy
                        if 0 <= nx < rows and 0 <= ny < cols and grid[nx][ny] == '1':
                            grid[nx][ny] = '0'
                            queue.append((nx, ny))
    return count

2.3 并查集(Union-Find)方法

对于大规模网格，并查集可能是更高效的解决方案：

python复制class UnionFind:
    def __init__(self, grid):
        m, n = len(grid), len(grid[0])
        self.count = 0
        self.parent = [0] * (m * n)
        self.rank = [0] * (m * n)
        
        for i in range(m):
            for j in range(n):
                if grid[i][j] == '1':
                    self.parent[i * n + j] = i * n + j
                    self.count += 1
    
    def find(self, i):
        if self.parent[i] != i:
            self.parent[i] = self.find(self.parent[i])
        return self.parent[i]
    
    def union(self, x, y):
        rootx = self.find(x)
        rooty = self.find(y)
        if rootx != rooty:
            if self.rank[rootx] > self.rank[rooty]:
                self.parent[rooty] = rootx
            elif self.rank[rootx] < self.rank[rooty]:
                self.parent[rootx] = rooty
            else:
                self.parent[rooty] = rootx
                self.rank[rootx] += 1
            self.count -= 1

def numIslands(grid):
    if not grid:
        return 0
    
    uf = UnionFind(grid)
    directions = [(1,0), (-1,0), (0,1), (0,-1)]
    m, n = len(grid), len(grid[0])
    
    for i in range(m):
        for j in range(n):
            if grid[i][j] == '1':
                for d in directions:
                    ni, nj = i + d[0], j + d[1]
                    if 0 <= ni < m and 0 <= nj < n and grid[ni][nj] == '1':
                        uf.union(i * n + j, ni * n + nj)
    return uf.count

3. 算法的时间与空间复杂度分析

3.1 DFS/BFS复杂度

对于DFS和BFS方法：

时间复杂度：O(M×N)，其中M是行数，N是列数。最坏情况下需要访问所有单元格。
空间复杂度：O(M×N)，最坏情况下整个网格都是陆地，递归深度或队列大小可能达到M×N。

3.2 并查集复杂度

并查集方法：

时间复杂度：O(M×N×α(M×N))，其中α是反阿克曼函数，增长极其缓慢，可以认为是常数时间。
空间复杂度：O(M×N)，用于存储父节点和秩数组。

4. 实际应用中的优化与变种

4.1 大规模数据的处理优化

当处理非常大的网格时，可以考虑以下优化：

分块处理：将大网格分成小块，分别处理后再合并结果
并行计算：利用多线程或分布式计算处理不同区域
内存优化：使用位图等方式压缩存储

4.2 问题变种与扩展

岛屿数量问题有多种变体：

统计岛屿的最大面积
考虑对角线连接的岛屿
动态岛屿数量（网格会随时间变化）
三维岛屿问题（扩展到三维空间）

例如，统计最大岛屿面积的代码：

python复制def maxAreaOfIsland(grid):
    max_area = 0
    for i in range(len(grid)):
        for j in range(len(grid[0])):
            if grid[i][j] == 1:
                max_area = max(max_area, dfs(grid, i, j))
    return max_area

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

5. 面试中的常见考察点

在技术面试中，面试官可能会从多个角度考察这个问题：

基础实现能力：能否正确写出DFS/BFS解决方案
算法优化：能否提出并实现更高效的解决方案
边界条件处理：空输入、全陆地、全水域等情况
复杂度分析：能否正确分析时间空间复杂度
问题扩展：如何处理变种问题

提示：在面试中，建议先提出DFS/BFS的解决方案，然后讨论优化空间，最后如果时间允许可以提到并查集方法。清晰地解释你的思路比直接写代码更重要。

6. 实际工程中的应用场景

岛屿数量问题看似抽象，但实际上有许多现实应用：

图像处理中的连通区域分析
地图服务中的陆地与水域划分
电路板设计中的连通性检查
医学图像中的病灶区域识别
游戏开发中的地形生成与区域划分

例如，在图像处理中，我们可以将像素值二值化后，使用类似的算法来识别和统计图像中的不同对象区域。

7. 常见错误与调试技巧

在实现岛屿数量算法时，开发者常遇到以下问题：

无限递归：忘记标记已访问的单元格
边界检查错误：数组越界访问
方向处理不全：漏掉某个相邻方向
输入处理不当：未考虑空输入或非标准输入

调试技巧：

打印中间状态，观察网格变化
使用小规模测试用例验证
逐步执行代码，检查递归/循环过程

例如，这是一个常见的错误实现：

python复制# 错误示例：忘记标记访问过的单元格
def dfs(grid, i, j):
    if i<0 or j<0 or i>=len(grid) or j>=len(grid[0]) or grid[i][j] != '1':
        return
    # 缺少 grid[i][j] = '0' 这行
    self.dfs(grid, i+1, j)
    self.dfs(grid, i-1, j)
    self.dfs(grid, i, j+1)
    self.dfs(grid, i, j-1)

这个错误会导致无限递归，因为相同的单元格会被反复访问。

8. 不同编程语言的实现差异

虽然算法思想相同，但在不同语言中实现方式有所差异：

8.1 Java实现

java复制public int numIslands(char[][] grid) {
    if (grid == null || grid.length == 0) return 0;
    
    int count = 0;
    for (int i = 0; i < grid.length; i++) {
        for (int j = 0; j < grid[0].length; j++) {
            if (grid[i][j] == '1') {
                dfs(grid, i, j);
                count++;
            }
        }
    }
    return count;
}

private void dfs(char[][] grid, int i, int j) {
    if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length || 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);
}

8.2 C++实现

cpp复制class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        if (grid.empty()) return 0;
        
        int count = 0;
        for (int i = 0; i < grid.size(); i++) {
            for (int j = 0; j < grid[0].size(); j++) {
                if (grid[i][j] == '1') {
                    dfs(grid, i, j);
                    count++;
                }
            }
        }
        return count;
    }
    
    void dfs(vector<vector<char>>& grid, int i, int j) {
        if (i < 0 || j < 0 || i >= grid.size() || j >= grid[0].size() || 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);
    }
};

8.3 JavaScript实现

javascript复制function numIslands(grid) {
    if (!grid || grid.length === 0) return 0;
    
    let count = 0;
    for (let i = 0; i < grid.length; i++) {
        for (let j = 0; j < grid[0].length; j++) {
            if (grid[i][j] === '1') {
                dfs(grid, i, j);
                count++;
            }
        }
    }
    return count;
}

function dfs(grid, i, j) {
    if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length || 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);
}

9. 性能测试与比较

为了比较不同算法的实际性能，我们设计了一个测试方案：

生成随机测试用例（不同大小的网格，不同岛屿数量）
测量每种算法的执行时间
分析内存使用情况

测试结果通常显示：

对于小网格（<100×100），三种方法性能差异不大
中等网格（1000×1000左右），BFS通常略快于DFS
超大网格（>10000×10000），并查集显示出优势
DFS在极端情况下可能出现栈溢出

注意：实际性能受编程语言、实现细节、硬件环境等因素影响，建议针对具体应用场景进行实测。

10. 学习资源与进阶方向

对于想深入理解这个问题的开发者，推荐以下资源：

《算法导论》中的图算法章节
LeetCode上的相关题目：
- 1. 岛屿数量（基础）
- 1. 岛屿的最大面积（变种）
- 1. 岛屿数量 II（动态版本）
在线可视化工具：观察算法执行过程
学术论文：关于并行计算解决大规模连通性问题

进阶学习方向：

并行图算法
分布式图计算框架（如Pregel）
图像处理中的连通组件分析
拓扑数据分析中的持久同调

在实际开发中遇到类似矩阵连通性问题时，岛屿数量问题的解决思路可以提供很好的参考。掌握这个问题的多种解法不仅能帮助你在技术面试中表现出色，也能提升你解决实际工程问题的能力。