岛屿的最大数目java实现

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        //首先需要确定一个于grid大小相等的矩阵用于标识节点是否被访问了
        int length1 = grid.length;
        int length2 = grid[0].length;
        boolean[][] visited = new boolean[length1][length2];
        //需要装备一个值来存储最大的岛屿面积，在访问每一个岛屿的时候使用打擂台的方式确定最大值
        int maxArea = 0;
        //着手访问grid种的每一个节点，每当遇到一个未曾访问过的新节点就搜索它的所有连接在一起的节点，然后接着处理下一个未曾发现的节点直到所有的节点都遍历完成
        for(int i = 0;i < length1;i++){
            for(int j = 0;j < length2;j++){
                //找到一个没有被访问过的节点
                if(grid[i][j] == 1 && !visited[i][j]){
                    //确定该节点的岛屿面积
                    int area = getArea(grid,visited,i,j);
                    maxArea = Math.max(maxArea,area);
                }
            }
        }
        return maxArea;
    }

    //使用深度优先搜索解决问题
    public int getAreas(int[][] grid,boolean[][] visited,int i,int j){
        //创建一个栈用于存储搜索的节点
        Stack<int[]> stack = new Stack<>();
        //先将发现的第一个节点入栈，并且标记已经访问
        stack.push(new int[]{i,j});
        visited[i][j] = true;
        //接着创建area和上下左右
        int area = 0;
        int dirs[][] = {{1,0},{-1,0},{0,-1},{0,1}};
        //栈不为空就出栈判断上下左右是否符合条件
        while(!stack.isEmpty()){
            int[] pos = stack.pop();
            area++;
            for(int[] dir : dirs){
                int r = dir[0] + pos[0];
                int c = dir[1] + pos[1];
                if((r >= 0 && r < grid.length) && (c >= 0 && c < grid[0].length) && grid[r][c] == 1 && !visited[r][c]){
                    stack.push(new int[]{r,c});
                    visited[r][c] = true;
                }
            }
        }
        return area;
    }

    //递归代码实现深度优先搜索
    public int getArea(int grid[][],boolean[][] visited,int i,int j){
        //准备上下左右集合
        int[][] dirs = {{1,0},{-1,0},{0,-1},{0,1}};
        //准备area
        int area = 1;
        visited[i][j] = true;
        //开始遍历每个节点需要做的事
        for(int[] dir : dirs){
            int r = dir[0] + i;
            int c = dir[1] + j;
            if((r >= 0 && r < grid.length) && (c >= 0 && c < grid[0].length) && grid[r][c] == 1 && !visited[r][c]){
                area += getArea(grid,visited,r,c);
            }
        }
        return area;
    }

    //使用广度优先搜索来确定岛屿的面积
    public int getAreag(int[][] grid,boolean[][] visited,int i,int j){
        //广度优先搜索需要创建一个队列来保存当前遍历节点的状态
        Queue<int[]> queue = new LinkedList<>();
        //首先入队当前节点，并且标记当前节点已经访问过了
        queue.add(new int[]{i,j});
        visited[i][j] = true;
        int area = 0;
        int dirs[][] = {{1,0},{-1,0},{0,-1},{0,1}};
        //接着的步骤就是不断从队列中取出节点遍历节点的上下左右元素是否为1时就加入不是就不管，直到队列为空为止
        while(!queue.isEmpty()){
            //每当取出一个节点就代表着我们的面积增加1
            int[] pos = queue.remove();
            area++;
            //遍历节点的上下左右元素
            for(int[] dir : dirs){
                int r = pos[0] + dir[0];
                int c = pos[1] + dir[1];
                if((r >= 0 && r < grid.length) && (c >= 0 && c < grid[0].length) && grid[r][c] == 1 && !visited[r][c]){
                    queue.add(new int[]{r,c});
                    visited[r][c] = true;
                }
            }
        }
        return area;
    }
}