岛屿数量

力扣200岛屿数量

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

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

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

输入:
11000
11000
00100
00011
输出: 3
解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。

思路很清晰，通过深搜或者广搜，遍历相邻的节点，并将节点标为0，这样就可以完全“消灭”一座岛屿。再继续遍历网格，当遇到‘1’的时候，岛屿数量加1。
下面是我写的广搜的代码，注意必须要在搜到陆地的第一时间将值标为‘0’，不然队列中会产生大量重复坐标，导致力扣超时。

class Solution {
    
    static int[][] direction = {{0,1},{0,-1},{1,0},{-1,0}};
    
    public int numIslands(char[][] grid) {

        if(grid == null) return 0;

        int maxRow = grid.length;
        if(maxRow == 0) return 0;
        int maxCol = grid[0].length;
        if(maxCol == 0) return 0;

        boolean[][] visited = new boolean[maxRow][maxCol];

        int islandsNum = 0;
        for(int i=0;i<maxRow;i++) {
            for(int j=0;j<maxCol;j++) {
                if(grid[i][j] == '1') {
                    islandsNum++;
                    deletIslands(grid,new int[]{i,j});
                }
            }
        }

        return islandsNum;

    }

    public void deletIslands(char[][] grid,int[] start) {

        int maxRow = grid.length;
        int maxCol = grid[0].length;

        Queue<int[]> queue = new LinkedList<>();
        queue.offer(start);
        grid[start[0]][start[1]] = '0';
        while(!queue.isEmpty()) {
            int[] currPosition = queue.poll();
            int currRow = currPosition[0], currCol = currPosition[1];

            for (int k = 0; k < 4; k++) {
                int dRow = currRow + direction[k][0];
                int dCol = currCol + direction[k][1];
                if (dRow >= 0 && dRow < maxRow && dCol >= 0 && dCol < maxCol && grid[dRow][dCol] == '1') {
                    grid[dRow][dCol] = '0';
                    queue.offer(new int[]{dRow, dCol});
                }
            }
        }
        return;
    }
}