使用场景:
遍历 和 寻找最短路径
算法:
1. 使用队列实现(先进先出)
2. 每次访问一个节点时将其邻居节点放入队列中,访问完后出队
3. 依次访问队列中的节点,直至队列为空或找到想要的节点
4. 如果不想重复访问节点(在图中),则设置HashSet哈希表来存储已经访问的节点,然后每次要添加新节点时先使用contains检验其是否在哈希表中。
图示:
访问根节点A,并将其邻居节点B,C,D入队,访问完后A出队。
访问队列中的第一个节点B,并将其邻居节点E入队,访问完后B出队。
访问当前队列中的第一个节点C,并将其邻居节点F入队,不想重复访问节点,所以E未入队,访问完后C出队。
访问当前队列中的第一个节点D,并将其邻居节点G入队,访问完后D出队。
至此,A的邻居节点,也就是距离A为1的节点访问完毕,接下来访问距离A为2的节点。
访问当前队列中的第一个节点E,子节点了,访问完后E出队。
访问当前队列中的第一个节点F,不想重复访问节点,所以G未入队,访问完后F出队。最后访问节点G,队列为空,结束。
例题:
1. 给你一个由 '1'
(陆地)和 '0'
(水)组成的的二维网格,请你计算网格中岛屿的数量。岛屿总是被水包围,并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。此外,你可以假设该网格的四条边均被水包围。(leetcode 200)
示例 1:
输入:grid = [ ["1","1","1","1","0"], ["1","1","0","1","0"], ["1","1","0","0","0"], ["0","0","0","0","0"] ] 输出:1
示例 2:
输入:grid = [ ["1","1","0","0","0"], ["1","1","0","0","0"], ["0","0","1","0","0"], ["0","0","0","1","1"] ] 输出:3
-----------------1 使用哈希表--------------------------------
import java.util.Vector;
class Solution{
public int numIslands(char[][] grid){
if(grid==null || grid.length==0)
return 0;
int m = grid.length;
int n = grid[0].length;
int count = 0;
Queue<Pair<Integer, Integer> > queue = new LinkedList<>();
HashSet<Pair<Integer, Integer> > set = new HashSet<>();
Vector<Pair<Integer, Integer> > directions = new Vector<>(Arrays.asList(new Pair<>(-1,0), new Pair<>(1,0), new Pair<>(0,-1), new Pair<>(0,1)));
//遍历二维数组
for(int i=0; i<m; ++i){
for(int j=0; j<n; ++j){
//如果是水或者这块陆地已经访问过,则直接下一个
if(grid[i][j] == '0' || set.contains(new Pair<>(i, j)))
continue;
//从这块没访问过的陆地开始往外扩展,直到没有相连的陆地可以访问
Pair<Integer, Integer> root = new Pair<>(i, j);
set.add(root);
queue.offer(root);
while(!queue.isEmpty()){
Pair<Integer, Integer> curPair = queue.poll();
for(Pair<Integer, Integer> d: directions){
int neighborI = curPair.getKey() + d.getKey();
int neighborJ = curPair.getValue() + d.getValue();
if(neighborI>=0 && neighborI<m && neighborJ>=0 && neighborJ<n && grid[neighborI][neighborJ] == '1' && !set.contains(new Pair<>(neighborI, neighborJ))){
Pair<Integer, Integer> neighborPair = new Pair<>(neighborI, neighborJ);
queue.offer(neighborPair);
set.add(neighborPair);
}
}
}
//岛屿数量加一
count++;
}
}
return count;
}
}
-------------将访问过的陆地置为1,使用i*n+j加密存储i,j-----------
class Solution{
public int numIslands(char[][] grid){
if(grid==null || grid.length==0)
return 0;
int m = grid.length;
int n = grid[0].length;
int count = 0;
for(int i=0; i<m; ++i){
for(int j=0; j<n; ++j){
if(grid[i][j] == '1'){
grid[i][j] = '0';
Queue<Integer> neighbor = new LinkedList<>();
neighbor.offer(i*n+j);
while(!neighbor.isEmpty()){
int key = neighbor.poll();
int curI = key/n;
int curJ = key%n;
if(curI-1>=0 && grid[curI-1][curJ]=='1'){
neighbor.offer((curI-1)*n+curJ);
grid[curI-1][curJ] = '0';
}
if(curI+1<m && grid[curI+1][curJ]=='1'){
neighbor.offer((curI+1)*n+curJ);
grid[curI+1][curJ] = '0';
}
if(curJ-1>=0 && grid[curI][curJ-1]=='1'){
neighbor.offer((curI)*n+curJ-1);
grid[curI][curJ-1] = '0';
}
if(curJ+1<n && grid[curI][curJ+1]=='1'){
neighbor.offer(curI*n+curJ+1);
grid[curI][curJ+1] = '0';
}
}
++count;
}
}
}
return count;
}
}