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

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

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

解题思路：

        // 类比二叉树的dfs方法； 递归检查左右子树

        // 将网格中的元素看作一个四叉的 就有四个（（看作四个子树），不同在于会出现重复遍历兜圈子

        // 因此需要在每个格子元素遍历后将其加一个标志 true 表示遍历过，false 表示没有遍历

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        // 类比二叉树的dfs方法； 递归检查左右子树
        // 将网格中的元素看作一个四叉的 就有四个（（看作四个子树），不同在于会出现重复遍历兜圈子
        // 因此需要在每个格子元素遍历后将其加一个标志 true 表示遍历过，false 表示没有遍历
        // 二叉树
        // dfs(treenode *root){
        // if (root == null) {
        //     return;
        // }
        // // 访问两个相邻结点：左子结点、右子结点
        // dfs(root.left);
        // dfs(root.right);
        // }
        // 网格深度优先遍历
        // void grid_dfs(vector<vector<char>>& grid,vector<vector<bool>>& grid_judg ,int r,int c){
        //     if(r > grid.size() || c > grid[0].size() || r<0 || c<0){ // 超出网格范围
        //         return; 
        //     }
        //     
        //     if(grid_jude[r][c] || grid[r][c] !=1 ){ // 判断是否为遍历过的岛屿
        //         return; 
        //     }
        //     grid_jude[r][c] = true;
        //     grid_dfs(grid,r-1,c); // 上面
        //     grid_dfs(grid,r+1,c); // 下面
        //     grid_dfs(grid,r,c-1); // 左面
        //     grid_dfs(grid,r,c+1); // 右面
        // }
        if (grid.empty() || grid[0].empty()) {
            return 0; // 如果网格为空，直接返回 0
        }

        int row = grid.size(), col = grid[0].size();
        int res = 0;
        vector<vector<bool>> grid_judg(row, vector<bool>(col, false)); // 保存是否遍历过

        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (grid[i][j] == '1' && !grid_judg[i][j]) {
                    ++res; // 发现一个新的岛屿
                    grid_dfs(grid, grid_judg, i, j); // 递归标记整个岛屿
                }
            }
        }

        return res;
    }

    void grid_dfs(vector<vector<char>>& grid, vector<vector<bool>>& grid_judg, int r, int c) {
        // 边界条件检查
        if (r < 0 || r >= grid.size() || c < 0 || c >= grid[0].size()) {
            return; // 超出网格范围
        }

        // 如果当前格子是水或已经访问过，直接返回
        if (grid[r][c] != '1' || grid_judg[r][c]) {
            return;
        }

        // 标记当前格子为已访问
        grid_judg[r][c] = true;
        // 递归访问上下左右四个方向
        grid_dfs(grid, grid_judg, r - 1, c); // 上面
        grid_dfs(grid, grid_judg, r + 1, c); // 下面
        grid_dfs(grid, grid_judg, r, c - 1); // 左面
        grid_dfs(grid, grid_judg, r, c + 1); // 右面
    }
};

dfs：

将网格中的元素看作一个四叉的 就有四个（（看作四个子树），不同在于会出现重复遍历兜圈子

因此需要在每个格子元素遍历后将其加一个标志 true 表示遍历过，false 表示没有遍历。

      void grid_dfs(vector<vector<char>>& grid,vector<vector<bool>>& grid_judg ,int r,int c){
            if(r > grid.size() || c > grid[0].size() || r<0 || c<0){ // 超出网格范围
                return; 
            }
            
            if(grid_jude[r][c] || grid[r][c] !=1 ){ // 判断是否为遍历过的岛屿
                return; 
            }
            grid_jude[r][c] = true;
            grid_dfs(grid,r-1,c); // 上面
            grid_dfs(grid,r+1,c); // 下面
            grid_dfs(grid,r,c-1); // 左面
            grid_dfs(grid,r,c+1); // 右面
        }