岛屿数量

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：

输入：grid = [
[“1”,“1”,“1”,“1”,“0”],
[“1”,“1”,“0”,“1”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“0”,“0”,“0”]
]
输出：1
示例 2：

输入：grid = [
[“1”,“1”,“0”,“0”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“1”,“0”,“0”],
[“0”,“0”,“0”,“1”,“1”]
]
输出：3
提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 300

grid[i][j] 的值为 ‘0’ 或 ‘1’
Related Topics
深度优先搜索
广度优先搜索
并查集
数组
矩阵

Java实现代码如下

package algorithm.array;

import org.junit.Test;

/**
 * numIslands
 *
 * @author allens
 * @date 2023/12/25
 */
public class NumIslands {

    public int numIslands(char[][] grid) {
        boolean flag = true;
        int count = 0;
        while (flag) {
            boolean has = false;
            for (int i = 0; i < grid.length; i++) {
                for (int j = 0; j < grid[i].length; j++) {
                    if (grid[i][j] == '1') {
                        has = true;
                        flag = recursive(grid, j, i);
                        if (flag) count ++;
                    }
                }
            }
            if (!has) break;
        }

        return count;
    }

    public boolean recursive (char[][] grid, int x, int y) {

        if (y >= grid.length || y < 0) return false;
        if (x >= grid[0].length || x < 0) return false;

        // 如果这个格子不是岛屿，直接返回
        if (grid[y][x] != '1') {
            return false;
        }
        grid[y][x] = '2'; // 将格子标记为「已遍历过」

        // 上
        recursive(grid, x, y - 1);
        // 下
        recursive(grid, x, y + 1);
        // 左
        recursive(grid,  x - 1, y);
        // 右
        recursive(grid,  x + 1, y);
        return true;
    }

    @Test
    public void testMain () {
        int result = numIslands(new char[][]{
                {'1', '1', '1', '1', '0'},
                {'1', '1', '0', '1', '0'},
                {'1', '1', '0', '0', '0'},
                {'0', '0', '1', '0', '1'}
        });
    }

}

网格遍历:

每一个格子都会往上下左右方向移动，但网格是有边界的，移动到边界之后要停止移动，同时移动到已经处理过后的格子的时候也停止移动。

比如grid[1][1]这个节点上下左右需要处理的逻辑。向上发现值为1可以继续处理，向左发现为0直接停止移动，向右向下同理。

public boolean recursive (char[][] grid, int x, int y) {

        if (y >= grid.length || y < 0) return false;
        if (x >= grid[0].length || x < 0) return false;

        // 如果这个格子不是岛屿，直接返回
        if (grid[y][x] != '1') {
            return false;
        }
        grid[y][x] = '2'; // 将格子标记为「标记已遍历过」，如果没有这段会导致无限循环

        // 上
        recursive(grid, x, y - 1);
        // 下
        recursive(grid, x, y + 1);
        // 左
        recursive(grid,  x - 1, y);
        // 右
        recursive(grid,  x + 1, y);
        return true; // 只要代码能进到这段就说明有小岛，直接返回true
}