200.岛屿数量

leetcode 200.岛屿数量

思路

基本思路就是双层for循环，遍历所有的格子为1的位置，这些位置就是岛屿，最终结果是需要知道岛屿的数量，这个数量在每一次遇到‘1’时只去遍历一次。所以问题就在于：
1、如何迭代？涉及边界条件等问题
2、如何计数以及识别已经访问过的位置？

代码

我写的时候使用了迭代的方式，是一个BFS，放入队列

class Solution {
    public int numIslands(char[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int count = 0;
        boolean[][] visited = new boolean[m][n];
        LinkedList<int[]> queue = new LinkedList();
        for(int i = 0;i<m;i++){
            for(int j = 0;j<n;j++){
                if(!visited[i][j] && grid[i][j] == '1'){
                    //说明可以以此点为原点查找岛屿
                    queue.add(new int[]{i,j});
                    //锁上，说明已经查找过
                    while(!queue.isEmpty()){
                        int[] indexs = queue.poll();
                        int x = indexs[0];
                        int y = indexs[1];
                        
                        if(x < 0 || x >= m) continue;
                        if(y < 0 || y >= n) continue;
                        if(visited[x][y]) continue;
                        if(grid[x][y] == '0') continue;
                        visited[x][y] = true;
                        queue.add(new int[]{x+1,y});
                        queue.add(new int[]{x-1,y});
                        queue.add(new int[]{x,y+1});
                        queue.add(new int[]{x,y-1});
                    }
                    count++;
                }
            }
        }
        return count;
    }
}

这个做法时间较长，但是空间略低于题解

更优解

使用递归求解，本质上是DFS

class Solution {
//利用深度递归解决，可以看图，并加记住这个模板，他可以解决岛屿中的问题，还有一题岛屿面积问题也是这个模板。
    public int numIslands(char[][] grid) {
        //定义一个表示岛屿数量的变量
        int count = 0;
        //这个两层for循环是用来遍历整张二维表格中所有的陆地
        //其中 i 表示行，j 表示列
        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;
    }
    public void dfs(char[][] grid,int i, int j){
        //防止 i 和 j 越界，也就是防止超出岛屿（上下左右）的范围。特别注意当遍历到海洋的时候也退出循环
        if(i<0||j<0||i>=grid.length||j>=grid[0].length||grid[i][j]=='0') 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);
    }
}

总结：最优解处提供了一个模板，这个模板可以帮忙做这类递归问题（BFS）