新增java解法

1. 調整語言順序
2. 新增java - DFS, java - BFS解法

problems/0695.岛屿的最大面积.md

@@ -189,6 +189,135 @@ public:
 ```
 
 # 其它语言版本
+## Java
+### DFS
+```java
+// DFS
+class Solution {
+    int[][] dir = {
+        {0, 1}, //right
+        {1, 0}, //down
+        {0, -1}, //left
+        {-1, 0} //up
+    };
+    boolean visited[][];
+    int count;
+    public int maxAreaOfIsland(int[][] grid) {
+        int res = 0;
+        visited = new boolean[grid.length][grid[0].length];
+        for(int i = 0; i < grid.length; i++){
+            for(int j = 0; j < grid[0].length; j++){
+                if(visited[i][j] == false && grid[i][j] == 1){
+                    count = 0;
+                    dfs(grid, i, j);
+                    res = Math.max(res, count);
+                }
+            }
+        }
+        return res;
+    }
+    private void dfs(int[][] grid, int x, int y){
+        if(visited[x][y] == true || grid[x][y] == 0)
+            return;
+        
+        visited[x][y] = true;
+        count++;
+
+        for(int i = 0; i < 4; i++){
+            int nextX = x + dir[i][0];
+            int nextY = y + dir[i][1];
+
+            if(nextX < 0 || nextY < 0 || nextX >= grid.length || nextY >= grid[0].length)
+                continue;
+            dfs(grid, nextX, nextY);
+        }
+    }
+}
+
+
+```
+### BFS
+```java
+//BFS
+class Solution {
+    int[][] dir = {
+        {0, 1}, {1, 0}, {0, -1}, {-1, 0}
+    };
+
+    int count;
+    boolean visited[][];
+
+    public int maxAreaOfIsland(int[][] grid) {
+        int res = 0;
+        visited = new boolean[grid.length][grid[0].length];
+        
+        for(int i = 0; i < grid.length; i++){
+            for(int j = 0; j < grid[0].length; j++){
+                if(visited[i][j] == false && grid[i][j] == 1){
+                    count = 0;
+                    bfs(grid, i, j);
+                    res = Math.max(res, count);
+                }
+            }
+        }
+        return res;
+    }
+    private void bfs(int[][] grid, int x, int y){
+        Queue<Integer> que = new LinkedList<>();
+        que.offer(x);
+        que.offer(y);
+        visited[x][y] = true;
+        count++;
+        
+        while(!que.isEmpty()){
+            int currX = que.poll();
+            int currY = que.poll();
+
+            for(int i = 0; i < 4; i++){
+                int nextX = currX + dir[i][0];
+                int nextY = currY + dir[i][1];
+                
+                if(nextX < 0 || nextY < 0 || nextX >= grid.length || nextY >= grid[0].length)
+                    continue;
+                if(visited[nextX][nextY] == false && grid[nextX][nextY] == 1){
+                    que.offer(nextX);
+                    que.offer(nextY);
+                    visited[nextX][nextY] = true;
+                    count++;
+                }
+            }
+        }
+    }
+}
+```
+### DFS 優化（遇到島嶼後，就把他淹沒）
+```java
+//这里使用深度优先搜索 DFS 来完成本道题目。我们使用 DFS 计算一个岛屿的面积，同时维护计算过的最大的岛屿面积。同时，为了避免对岛屿重复计算，我们在 DFS 的时候对岛屿进行 “淹没” 操作，即将岛屿所占的地方置为 0。
+public int maxAreaOfIsland(int[][] grid) {
+    int res = 0;
+    for(int i = 0;i < grid.length;i++){
+        for(int j = 0;j < grid[0].length;j++){
+        	//每遇到一个岛屿就计算这个岛屿的面积同时”淹没“这个岛屿
+            if(grid[i][j] == 1){
+            	//每次计算一个岛屿的面积都要与res比较，维护最大的岛屿面积作为最后的答案
+                res = Math.max(res,dfs(grid,i,j));
+            }
+        }
+    }
+    return res;
+}
+public int dfs(int[][] grid,int i,int j){
+	//搜索边界：i，j超过grid的范围或者当前元素为0，即当前所在的地方已经是海洋
+    if(i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == 0) return 0;
+    //淹没土地，防止后续被重复计算
+    grid[i][j] = 0;
+    //递归的思路：要求当前土地(i,j)所在的岛屿的面积，则等于1加上下左右相邻的土地的总面积
+    return 1 + dfs(grid,i - 1,j) +
+               dfs(grid,i + 1,j) +
+               dfs(grid,i,j + 1) +
+               dfs(grid,i,j - 1);
+}
+```
 
 ## Python
 ### BFS
@@ -261,39 +390,6 @@ class Solution:
             if 0 <= new_x < len(grid) and 0 <= new_y < len(grid[0]): 
                 self.dfs(grid, visited, new_x, new_y)
 ```
-
-
-
-## Java
-
-这里使用深度优先搜索 DFS 来完成本道题目。我们使用 DFS 计算一个岛屿的面积，同时维护计算过的最大的岛屿面积。同时，为了避免对岛屿重复计算，我们在 DFS 的时候对岛屿进行 “淹没” 操作，即将岛屿所占的地方置为 0。
-
-```java
-public int maxAreaOfIsland(int[][] grid) {
-    int res = 0;
-    for(int i = 0;i < grid.length;i++){
-        for(int j = 0;j < grid[0].length;j++){
-        	//每遇到一个岛屿就计算这个岛屿的面积同时”淹没“这个岛屿
-            if(grid[i][j] == 1){
-            	//每次计算一个岛屿的面积都要与res比较，维护最大的岛屿面积作为最后的答案
-                res = Math.max(res,dfs(grid,i,j));
-            }
-        }
-    }
-    return res;
-}
-public int dfs(int[][] grid,int i,int j){
-	//搜索边界：i，j超过grid的范围或者当前元素为0，即当前所在的地方已经是海洋
-    if(i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == 0) return 0;
-    //淹没土地，防止后续被重复计算
-    grid[i][j] = 0;
-    //递归的思路：要求当前土地(i,j)所在的岛屿的面积，则等于1加上下左右相邻的土地的总面积
-    return 1 + dfs(grid,i - 1,j) +
-               dfs(grid,i + 1,j) +
-               dfs(grid,i,j + 1) +
-               dfs(grid,i,j - 1);
-}
-```
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>