leetcode200.岛屿数量（C语言）

题目描述

leetcode刷题地址
给你一个由 ‘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’

解题思路

方法一：深度优先遍历

我们可以将二维网格看成一个无向图，竖直或水平相邻的 1 之间有边相连。
为了求出岛屿的数量，我们可以扫描整个二维网格。如果一个位置为 1，则以其为起始节点开始进行深度优先搜索。在深度优先搜索的过程中，每个搜索到的 1 都会被重新标记为 0。
最终岛屿的数量就是我们进行深度优先搜索的次数。

void dfs(char** grid,int x,int y,int row,int col){
    if(x<0||y<0||x>=row||y>=col||grid[x][y]=='0')
    return;
    grid[x][y]='0';
     dfs(grid,x-1,y,row,col);
      dfs(grid,x+1,y,row,col);
       dfs(grid,x,y-1,row,col);
         dfs(grid,x,y+1,row,col);
 }
int numIslands(char** grid, int gridSize, int* gridColSize) {
    if(gridSize==0||grid==NULL)
        return 0;
    int count=0;
    for(int i=0;i<gridSize;i++){
        for(int j=0;j<*gridColSize;j++){
            if(grid[i][j]=='1'){
                 count++;
                 dfs(grid,i,j,gridSize,*gridColSize);//遍历其相邻网格
            }
           
        }
    }
    return count;
}
 

方法二：广度优先搜索

同样地，我们也可以使用广度优先搜索代替深度优先搜索。
为了求出岛屿的数量，我们可以扫描整个二维网格。如果一个位置为 1，则将其加入队列，开始进行广度优先搜索。在广度优先搜索的过程中，每个搜索到的 1 都会被重新标记为 0。直到队列为空，搜索结束。
最终岛屿的数量就是我们进行广度优先搜索的次数。

typedef struct {
    int x;
    int y;
} Coordinate;

int numIslands(char** grid, int gridSize, int* gridColSize) {
    if (grid == NULL || gridSize == 0) {
        return 0;
    }

    int result = 0;
    int row = gridSize;
    int col = *gridColSize;
    Coordinate* queue = malloc(sizeof(Coordinate) * row * col);
    int front = 0, rear = 0;

    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            if (grid[i][j] == '1') {
                result++;
                queue[rear++] = (Coordinate){i, j};
                grid[i][j] = '0';

                while (front != rear) {
                    Coordinate cur = queue[front++];
                    int x = cur.x;
                    int y = cur.y;

                    if (x - 1 >= 0 && grid[x - 1][y] == '1') {
                        queue[rear++] = (Coordinate){x - 1, y};
                        grid[x - 1][y] = '0';
                    }
                    if (y - 1 >= 0 && grid[x][y - 1] == '1') {
                        queue[rear++] = (Coordinate){x, y - 1};
                        grid[x][y - 1] = '0';
                    }
                    if (x + 1 < row && grid[x + 1][y] == '1') {
                        queue[rear++] = (Coordinate){x + 1, y};
                        grid[x + 1][y] = '0';
                    }
                    if (y + 1 < col && grid[x][y + 1] == '1') {
                        queue[rear++] = (Coordinate){x, y + 1};
                        grid[x][y + 1] = '0';
                    }
                }
            }
        }
    }

    free(queue);
    return result;
}