【LeetCode】200. 岛屿数量（JAVA）（非100%）

原题地址：https://leetcode-cn.com/problems/number-of-islands/

题目描述：
给定一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。

示例 1:
输入:
11110
11010
11000
00000
输出: 1

示例 2:
输入:
11000
11000
00100
00011
输出: 3

解题方案：

可以采用广度优先遍历（队列）和深度优先遍历（递归），当找到一个为陆地的点时，遍历它的上下左右四个点，并将遍历过的点置为0，完成一次遍历后数量加一，再找下一个为陆地的点。
代码：
广度优先：

class Solution {
    public int numIslands(char[][] grid) {
        int count = 0;
        int m = grid.length;
        if(m == 0)
            return 0;
        int n = grid[0].length;
        if(n == 0)
            return 0;
        Queue<Integer> q = new LinkedList<>();
        for(int i = 0; i < m; i ++)
        {
            for(int j = 0; j < n; j ++)
            {
                if(grid[i][j] == '1')
                {
                    int index = i * n + j;
                    q.add(index);
                    grid[i][j] = '0';
                    while(!q.isEmpty())
                    {
                        int tmp = q.remove();
                        int x = tmp / n;
                        int y = tmp % n;
                        if(y - 1 >= 0 && grid[x][y - 1] == '1')
                        {
                            q.add(x * n + (y - 1));
                            grid[x][y - 1] = '0';
                        }
                        if(y + 1 < n && grid[x][y + 1] == '1')
                        {
                            q.add(x * n + (y + 1));
                            grid[x][y + 1] = '0';
                        }
                        if(x - 1 >= 0 && grid[x - 1][y] == '1')
                        {
                            q.add((x - 1) * n + y);
                            grid[x - 1][y] = '0';
                        }
                        if(x + 1 < m && grid[x + 1][y] == '1')
                        {
                            q.add((x + 1) * n + y);
                            grid[x + 1][y] = '0';
                        }
                    }
                    count ++;
                }
            }
        }
        return count;
    }
}

深度优先：

class Solution {
    public int numIslands(char[][] grid) {
        int m = grid.length;
        if(m == 0) return 0;
        int n = grid[0].length;
        if(n == 0) return 0;
        int count = 0;
        for(int i = 0; i < m; i ++)
        {
            for(int j = 0; j < n; j ++)
            {
                if(grid[i][j] == '1')
                {
                    dfsIslands(grid, i, j);
                    count ++;
                }
            }
        }
        return count;
        
    }
    public void dfsIslands(char[][] grid, int x, int y)
    {
        if(x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] == '0')
            return;
        if(grid[x][y] == '1')
        {
            grid[x][y] = '0';
            dfsIslands(grid, x - 1, y);
            dfsIslands(grid, x + 1, y);
            dfsIslands(grid, x, y - 1);
            dfsIslands(grid, x, y + 1);
        }
    }
}