Java实现广度优先遍历的示例详解
什么是广度优先
广度就是扩展开，广度优先的意思就是尽量扩展开。所以在算法实现的时候，就是一个循环遍历枚举每一个邻接点。其基本思路就是按层扩展，扩得越广越好。
伪代码如下：
for(int i = 0; i < children.size(); i++){
children.get(i); // 调用每一个子节点
}
一个简单的例子
我们以一个简单的迷宫为例，以1代表墙，0代表路径，我们构造一个具有出入口的迷宫。
1 1 0 1 1 1 1 1 1
1 0 0 0 0 0 0 1 1
1 0 1 1 1 1 0 1 1
1 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 0 1
以上面这个0为入口，下面这个0为出口，那么广度优先的算法遍历顺序就为：dp[0][2]为入口，扩展出dp[1][2]，继续扩展出dp[1][1]和dp[1][3]，我把这个过程列在下面了：
第一步：
dp[0][2] -> dp[1][2]
第二步：
dp[1][2] -> dp[1][1] & dp[1][3]
第三步：
dp[1][1] -> dp[2][1]
dp[1][3] -> dp[1][4]
第四步：
dp[2][1] -> dp[3][1]
dp[1][4] -> dp[1][5]
第五步：
dp[3][1] -> dp[3][2]
dp[1][5] -> dp[1][6]
第六步：
dp[3][2] -> dp[3][3]
dp[1][6] -> dp[2][6]
第七步：
dp[3][3] -> dp[3][4]
dp[2][6] -> dp[3][6]
第八步：
dp[3][4] -> dp[3][5]
dp[3][6] -> dp[3][7]
第九步：
dp[3][5] -> dp[3][6]
dp[3][7] -> dp[4][7] ->到达终点
算法结束
好了，如果你已经懂了，就赶快去写代码吧。你可以使用一个二维数组来构建这个迷宫，然后思考怎么实现状态流转。
程序实现
要实现一个简单例子中的程序，我们需要编写输入函数，处理迷宫为01字符数组，然后编写bfs函数作为主体函数，然后我们怎么让代码表现出行走状态呢？假定当前坐标为 x,y，要行走，本质上就是判断 (x-1,y) (x+1,y) (x,y+1) (x,y-1) 是否可以走，所以我们需要编写一个判定函数，用来验证边界条件，这也是bfs里面的核心函数之一。以Java代码为例
package com.chaojilaji.book;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class Bfs {
public static String[][] getInput(String a) {
String[] b = a.split("\n");
int n = 0, m = 0;
m = b.length;
for (int i = 0; i < b.length; i++) {
String[] c = b[i].split(" ");
n = c.length;
break;
}
String[][] x = new String[m][n];
for (int i = 0; i < b.length; i++) {
String[] c = b[i].split(" ");
for (int j = 0; j < c.length; j++) {
x[i][j] = c[j];
}
}
return x;
}
public static Boolean canAdd(String[][] a, Integer x, Integer y, Set<Integer> cache) {
int m = a[0].length;
int n = a.length;
if (x < 0 || x >= m) {
return false;
}
if (y < 0 || y >= n) {
return false;
}
if (a[y][x].equals("0") && !cache.contains(x * 100000 + y)) {
cache.add(x * 100000 + y);
return true;
}
return false;
}
public static Integer bfs(String[][] a) {
// 规定入口在第一行，出口在最后一行
int m = a[0].length;
int n = a.length;
int rux = -1, ruy = 0;
int chux = -1, chuy = n - 1;
for (int i = 0; i < m; i++) {
if (a[0][i].equals("0")) {
// TODO: 2022/1/11 找到入口
rux = i;
}
if (a[n - 1][i].equals("0")) {
chux = i;
}
}
Integer ans = 0;
Set<Integer> cache = new HashSet<>();
cache.add(rux * 100000 + ruy);
List<Integer> nexts = new ArrayList<>();
nexts.add(rux * 100000 + ruy);
while (true) {
if (nexts.size() == 0) {
ans = -1;
break;
}
int flag = 0;
List<Integer> tmpNexts = new ArrayList<>();
for (Integer next : nexts) {
int x = next / 100000;
int y = next % 100000;
if (x == chux && y == chuy) {
flag = 1;
break;
}
// TODO: 2022/1/11 根据现在的坐标，上下左右走
if (canAdd(a, x - 1, y, cache)) tmpNexts.add((x - 1) * 100000 + y);
if (canAdd(a, x + 1, y, cache)) tmpNexts.add((x + 1) * 100000 + y);
if (canAdd(a, x, y - 1, cache)) tmpNexts.add(x * 100000 + (y - 1));
if (canAdd(a, x, y + 1, cache)) tmpNexts.add(x * 100000 + (y + 1));
}
nexts.clear();
nexts.addAll(tmpNexts);
if (flag == 1) {
break;
}else {
ans++;
}
}
return ans;
}
public static void demo() {
String a = "1 1 0 1 1 1 1 1 1\n" +
"1 0 0 0 0 0 0 1 1\n" +
"1 0 1 1 1 1 0 1 1\n" +
"1 0 0 0 0 0 0 0 1\n" +
"1 1 1 1 1 1 1 0 1";
String[][] b = getInput(a);
Integer ans = bfs(b);
System.out.println(ans == -1 ? "不可达" : "可达，最短距离为" + ans+"步");
}
public static void main(String[] args) {
demo();
}
}
这是数组的写法，这也是这个简单场景的写法。不过在我们的实际生活中，更多的会使用队列来实现广度优先搜索。队列模式下广度优先搜索的伪代码如下：
queue a;
while(!a.empty()){
a.take();
处理
将扩展出来的结果入队
}
那么上面这个迷宫，我们就可以使用标准广度优先模板来实现，具体代码如下：
public static Integer bfsQueue(String[][] a) {
Queue<Integer> queue = new LinkedList<>();
int m = a[0].length;
int n = a.length;
int rux = -1, ruy = 0;
int chux = -1, chuy = n - 1;
for (int i = 0; i < m; i++) {
if (a[0][i].equals("0")) {
// TODO: 2022/1/11 找到入口
rux = i;
}
if (a[n - 1][i].equals("0")) {
chux = i;
}
}
Integer ans = 0;
Set<Integer> cache = new HashSet<>();
cache.add(rux * 100000 + ruy);
queue.add(rux * 100000 + ruy);
Map<Integer, Integer> buzi = new HashMap<>();
buzi.put(rux * 100000 + ruy, 0);
int flag = 0;
while (!queue.isEmpty()) {
Integer val = queue.poll();
int x = val / 100000;
int y = val % 100000;
if (x == chux && y == chuy) {
flag = 1;
ans = buzi.get(x * 100000 + y);
break;
}
// TODO: 2022/1/11 根据现在的坐标，上下左右走
if (canAdd(a, x - 1, y, cache)) {
buzi.put((x - 1) * 100000 + y, buzi.get(x * 100000 + y)+1);
queue.add((x - 1) * 100000 + y);
}
if (canAdd(a, x + 1, y, cache)) {
buzi.put((x + 1) * 100000 + y, buzi.get(x * 100000 + y)+1);
queue.add((x + 1) * 100000 + y);
}
if (canAdd(a, x, y - 1, cache)) {
buzi.put(x * 100000 + (y - 1), buzi.get(x * 100000 + y)+1);
queue.add(x * 100000 + (y - 1));
}
if (canAdd(a, x, y + 1, cache)) {
buzi.put(x * 100000 + y + 1, buzi.get(x * 100000 + y)+1);
queue.add(x * 100000 + (y + 1));
}
}
if (flag == 1){
return ans;
}
return -1;
}
这段代码就可以替换掉上一段代码中的bfs函数。将上面的代码合并到一起，执行的结果为：
可见，两段代码的结果是一致的。
总结
简单总结一下，广度优先算法实现的时候主要需要解决两个问题。即，如何扩展（行走），临界判断。
到此这篇关于Java实现广度优先遍历的示例详解的文章就介绍到这了,更多相关Java广度优先遍历内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
这篇文章主要介绍了Java split函数拆分后变成null问题解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2020-10-10
这篇文章主要介绍了IDEA的TODO的使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2024-01-01
这篇文章主要为大家介绍了Eureka源码核心类预备知识详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-10-10
这篇文章主要介绍了Java文件拒绝访问问题及解决,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2023-12-12
日志框架是一种用于记录和管理应用程序运行时信息的软件组件,它通常提供了一套API让开发人员能够在代码中插入日志语句,下面我们就来学习一下如何手写一个日志框架吧2023-12-12
这篇文章主要为大家详细介绍了Java微信公众平台开发第十四步，微信web开发者工具的使用方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2017-04-04
这篇文章主要介绍了java数组算法例题代码详解(冒泡排序,选择排序),本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下2021-07-07
解释为什么Java中“1000==1000”为false而”100==100“为true
在日常编程中,我们经常遇到一些看似简单却隐藏着复杂逻辑的问题,这篇文章主要介绍了解释为什么Java中“1000==1000”为false而”100==100“为true,需要的朋友可以参考下2024-01-01
这篇文章主要为大家详细介绍了SpringBoot动态修改yml配置文件的方法，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能够给你带来帮助2022-03-03
SpringBoot配置文件application.properties的使用
这篇文章主要介绍了SpringBoot配置文件application.properties的使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2024-05-05
最新评论