leecode200

给定一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。

示例 1:

输入:
11110
11010
11000
00000

输出: 1
示例 2:

输入:
11000
11000
00100
00011

输出: 3

深度遍历二维数组，将遍历到为’1’的作为根节点，使用递归将周围所有为’1’的换为’0’。计算遍历到的’1’的数

代码实现：

/**
 * leecode 200 :
 	给定一个由 '1'（陆地）和 '0'（水）组成的的二维网格，计算岛屿的数量。
 	一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。
 	你可以假设网格的四个边均被水包围。
		示例 1:	实例二
		输入:	输入:
		11110	11000
		11010	11000
		11000	00100
		00000	00011
		输出: 1	3
 */
public class Leecode200 {
		/**
		 * 解题思路： 
		 * 遍历二维数组，当该数为'1'时表示岛屿，
		 * 如果遇到为1就给numsIslands+1;并把该索引位置周围的
		 * 所有连接的‘1’定义为'0'
		 * @param grid
		 * @return
		 */
	  public static int numIslands(char[][] grid) {
	    	//健壮性
	    	if(grid == null || grid.length==0) {
	    		return 0;
	    	}
	    	//一维长度
	        int nr = grid.length;
	        //二维长度
	        int nc = grid[0].length;
	        int numIslands = 0;
	        //遍历数组
	        for(int r= 0 ; r<nr;r++){
	            for(int c = 0 ; c<nc;c++){
	                if(grid[r][c]=='1'){
	                    numIslands++;
	                    //把该1连接的所有1全部变成0--递归
	                    dfs(grid,r,c);
	                }
	            }
	        }
	        return numIslands;
	    }
	    private static void dfs(char[][] grid,int index1,int index2){
	        int nc = grid.length;
	        int nr = grid[0].length;
	        if(index1<0 || index2<0 || index1>=nc || index2>=nr || grid[index1][index2]=='0'){
	            return;
	        }
	        grid[index1][index2] = '0';
	        //把周围所有连接的为'1'的数定义为'0'
	        dfs(grid,index1-1,index2);
	        dfs(grid,index1+1,index2);
	        dfs(grid,index1,index2-1);
	        dfs(grid,index1,index2+1);
	    }
	    public static void main(String[] args) {
	    	char[][] grid = {{'1','1','1','1','0'},{'1','1','0','1','0'},{'1','1','0','0','0'},{'0','0','0','0','0'}};
	    	
	    	System.out.println(numIslands(grid));
	    }
}