Leetcode 200 島嶼數量（搜索 java）

  如何設計深度優先搜索(DFS)

搜索到位置，進行一個標記，按照上下左右搜索，直到某一個點的深度遍歷全都搜索完畢，島嶼數量加1

小象學院給的是使用一個輔助數組進行標記，其實用原先的一個數組也是可以的，遍歷中心位之後，如果中心位是1，count++將中心位置爲非1的數字就好了，我看網上有置爲0的，我們爲了和水域也分開比較，我們將遍歷過的土地置爲1.

 我們

 

如何設計寬度優先搜索（BFS） 

寬度搜索需要藉助隊列記錄搜索到的節點

 DFS代碼

class Solution {
    public int numIslands(char[][] grid) {
        int x = grid.length;//行
        //邊界條件
        int counts_island=0;
        if(grid != null && x>0 ){
            int y = grid[0].length;//列
            for(int i=0;i<x;i++){
                for(int j=0;j<y;j++){
                    if(grid[i][j]=='1'){
                        DFS(i,j,grid);
                        counts_island++;
                    }
                }
            }
        }
        return counts_island;
    }
    public void DFS(int i, int j, char[][] grid){
        //遞歸結束條件
        if(i<0||j<0||i>grid.length-1||j>grid[0].length-1){
            return;
        }
        if(grid[i][j]=='1'){
            //中心位置重置
            grid[i][j]='2';
            //上
            DFS(i-1,j,grid);
            //下
             DFS(i+1,j,grid);
            //左
             DFS(i,j-1,grid);
            //右
            DFS(i,j+1,grid);
        }
        
    }
}

bfs是從網上找的代碼，藉助隊列

class Solution {
    public int numIslands(char[][] grid) {
        // corner case
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
           return 0; 
        }
        int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        
        int count = 0;
        int rows = grid.length;
        int cols = grid[0].length;
        
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] == '1') {
                    count++;
                    LinkedList<int []> queue = new LinkedList<int []>();
                    queue.add(new int[]{i, j});
                    while (!queue.isEmpty()) {
                        int[] cur = queue.poll();
                        for (int[] dir : dirs) {
                            int x = cur[0] + dir[0];
                            int y = cur[1] + dir[1];
                            if(x >= 0 && x < rows && y >= 0 && y < cols && grid[x][y] =='1'){
                                grid[x][y] = '0';
                                queue.add(new int[]{x, y});
                            }
                        }
                    }
                }
            }
        }
        return count;
    }
}

 其實bfs應該不難，多了一個隊列，保存遍歷的節點，然後再遍歷這些節點能夠遍歷到的節點

 

總的來說，還是深度優先遍歷好理解啊哈哈，上下左右四個遞歸就好了我