java 力扣 200.岛屿数量

最新推荐文章于 2023-12-17 23:35:00 发布

DT-阿飞

最新推荐文章于 2023-12-17 23:35:00 发布

阅读量219

点赞数

分类专栏：力扣文章标签： dfs 字符串 leetcode 算法哈希表

本文链接：https://blog.csdn.net/Dane_liya/article/details/117221624

版权

力扣专栏收录该内容

42 篇文章 0 订阅

订阅专栏

这篇博客探讨了两种不同的算法——深度优先搜索（DFS）和广度优先搜索（BFS）来解决在二维数组中计算连通岛屿数量的问题。通过遍历二维数组并标记已访问的元素，这两种方法都能有效地计算出连通的'1'（代表陆地）的数量。文章详细展示了每种方法的实现代码，并比较了它们的优缺点。

摘要由CSDN通过智能技术生成

1.题目

2.解法

①二维数组+DFS

class Solution {
    public int numIslands(char[][] grid) {
        if(grid.length == 0 || grid[0].length == 0){
            return 0;
        }
        int res = 0;
        int row = grid.length;
        int col = grid[0].length;
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(grid[i][j] == '1'){
                    res += 1;
                    dfs(grid, i, j, row, col);
                }
            }
        }
        return res;
    }
    private 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);
    }
}

②二维数组，队列+BFS

class Solution {
    public int numIslands(char[][] grid) {
        if(grid.length == 0 || grid[0].length == 0){
            return 0;
        }
        int res = 0;
        int row = grid.length;
        int col = grid[0].length;
        Queue<List<Integer>> queue = new LinkedList<List<Integer>>();
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(grid[i][j] == '1'){
                    res += 1;
                    grid[i][j] = '0';
                    queue.offer(new ArrayList<Integer>(Arrays.asList(i, j)));
                    while(queue.size() > 0){
                        List<Integer> temp = queue.poll();
                        int x = temp.get(0);
                        int y = temp.get(1);
                        if(x - 1 >= 0 && grid[x-1][y] == '1'){
                            grid[x-1][y] = '0';
                            queue.offer(new ArrayList<Integer>(Arrays.asList(x-1, y)));
                        }
                        if(x + 1 < row && grid[x+1][y] == '1'){
                            grid[x+1][y] = '0';
                            queue.offer(new ArrayList<Integer>(Arrays.asList(x+1, y)));
                        }
                        if(y - 1 >= 0 && grid[x][y-1] == '1'){
                            grid[x][y-1] = '0';
                            queue.offer(new ArrayList<Integer>(Arrays.asList(x, y-1)));
                        }
                        if(y + 1 < col && grid[x][y+1] == '1'){
                            grid[x][y+1] = '0';
                            queue.offer(new ArrayList<Integer>(Arrays.asList(x, y+1)));
                        }
                    }
                }
            }
        }
        return res;
    }
}