200. 岛屿数量

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-islands
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

深度优先遍历

class Solution {

    private final int[] dx = {0, 1, 0, -1};

    private final int[] dy = {1, 0, -1, 0};

    private void solve(char[][] grid, int x, int y) {
        grid[x][y] = '2';
        for (int i = 0; i < 4; ++i) {
            int nx = dx[i] + x;
            int ny = dy[i] + y;
            if (nx >= 0 && nx < grid.length && ny >= 0 && ny < grid[0].length && grid[nx][ny] == '1') {
                solve(grid, nx, ny);
            }
        }
    }

    private void recover(char[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return;
        }
        for (int i = 0; i < grid.length; ++i) {
            for (int j = 0; j < grid[0].length; ++j) {
                if (grid[i][j] == '2') {
                    grid[i][j] = '1';
                }
            }
        }
    }

    public int numIslands(char[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return 0;
        }

        int ret = 0;
        for (int i = 0; i < grid.length; ++i) {
            for (int j = 0; j < grid[0].length; ++j) {
                if (grid[i][j] == '1') {
                    ret++;
                    solve(grid, i, j);
                }
            }
        }
        recover(grid);
        return ret;
    }
}

广度优先遍历

import java.util.LinkedList;

class Solution {

    private final int[] dx = {0, 1, 0, -1};

    private final int[] dy = {1, 0, -1, 0};

    private int solve(char[][] grid) {
        int ret = 0;
        LinkedList<Point> queue = new LinkedList<>();
        for (int i = 0; i < grid.length; ++i) {
            for (int j = 0; j < grid[0].length; ++j) {
                if (grid[i][j] == '1') {
                    ret++;
                    grid[i][j] = '2';
                    queue.offer(new Point(i, j));
                    while (!queue.isEmpty()) {
                        Point node = queue.poll();
                        for (int k = 0; k < 4; ++k) {
                            int x = node.x + dx[k];
                            int y = node.y + dy[k];
                            if (x >= 0 && x < grid.length && y >= 0 && y < grid[0].length && grid[x][y] == '1') {
                                grid[x][y] = '2';
                                queue.offer(new Point(x, y));
                            }
                        }
                    }
                }
            }
        }
        return ret;
    }

    private void recover(char[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return;
        }
        for (int i = 0; i < grid.length; ++i) {
            for (int j = 0; j < grid[0].length; ++j) {
                if (grid[i][j] == '2') {
                    grid[i][j] = '1';
                }
            }
        }
    }

    public int numIslands(char[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return 0;
        }

        int ret = solve(grid);
        recover(grid);
        return ret;
    }
}

class Point {
    int x;
    int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

并查集