深度优先搜索(DFS)与广度优先搜索(BFS)的Java实现
基础部分
在图中实现最基本的操作之一就是搜索从一个指定顶点可以到达哪些顶点,比如从武汉出发的高铁可以到达哪些城市,一些城市可以直达,一些城市不能直达。现在有一份全国高铁模拟图,要从某个城市(顶点)开始,沿着铁轨(边)移动到其他城市(顶点),有两种方法可以用来搜索图:深度优先搜索(DFS)和广度优先搜索(BFS)。它们最终都会到达所有连通的顶点,深度优先搜索通过栈来实现,而广度优先搜索通过队列来实现,不同的实现机制导致不同的搜索方式。
深度优先搜索
深度优先搜索算法有如下规则:
规则1:如果可能,访问一个邻接的未访问顶点,标记它,并将它放入栈中。
规则2:当不能执行规则 1 时,如果栈不为空,就从栈中弹出一个顶点。
规则3:如果不能执行规则 1 和规则 2 时,就完成了整个搜索过程。
对于上图,应用深度优先搜索如下:假设选取 A 顶点为起始点,并且按照字母优先顺序进行访问,那么应用规则 1 ,接下来访问顶点 B,然后标记它,并将它放入栈中;再次应用规则 1,接下来访问顶点 F,再次应用规则 1,访问顶点 H。我们这时候发现,没有 H 顶点的邻接点了,这时候应用规则 2,从栈中弹出 H,这时候回到了顶点 F,但是我们发现 F 也除了 H 也没有与之邻接且未访问的顶点了,那么再弹出 F,这时候回到顶点 B,同理规则 1 应用不了,应用规则 2,弹出 B,这时候栈中只有顶点 A了,然后 A 还有未访问的邻接点,所有接下来访问顶点 C,但是 C又是这条线的终点,所以从栈中弹出它,再次回到 A,接着访问 D,G,I,最后也回到了 A,然后访问 E,但是最后又回到了顶点 A,这时候我们发现 A没有未访问的邻接点了,所以也把它弹出栈。现在栈中已无顶点,于是应用规则 3,完成了整个搜索过程。
深度优先搜索在于能够找到与某一顶点邻接且没有访问过的顶点。这里以邻接矩阵为例,找到顶点所在的行,从第一列开始向后寻找值为1的列;列号是邻接顶点的号码,检查这个顶点是否未访问过,如果是这样,那么这就是要访问的下一个顶点,如果该行没有顶点既等于1(邻接)且又是未访问的,那么与指定点相邻接的顶点就全部访问过了(后面会用算法实现)。
广度优先搜索
深度优先搜索要尽可能的远离起始点,而广度优先搜索则要尽可能的靠近起始点,它首先访问起始顶点的所有邻接点,然后再访问较远的区域,这种搜索不能用栈实现,而是用队列实现。
规则1:访问下一个未访问的邻接点(如果存在),这个顶点必须是当前顶点的邻接点,标记它,并把它插入到队列中。
规则2:如果已经没有未访问的邻接点而不能执行规则 1 时,那么从队列列头取出一个顶点(如果存在),并使其成为当前顶点。
规则3:如果因为队列为空而不能执行规则 2,则搜索结束。
对于上面的图,应用广度优先搜索:以A为起始点,首先访问所有与 A 相邻的顶点,并在访问的同时将其插入队列中,现在已经访问了 A,B,C,D和E。这时队列(从头到尾)包含 BCDE,已经没有未访问的且与顶点 A 邻接的顶点了,所以从队列中取出B,寻找与B邻接的顶点,这时找到F,所以把F插入到队列中。已经没有未访问且与B邻接的顶点了,所以从队列列头取出C,它没有未访问的邻接点。因此取出 D 并访问 G,D也没有未访问的邻接点了,所以取出E,现在队列中有 FG,在取出 F,访问 H,然后取出 G,访问 I,现在队列中有 HI,当取出他们时,发现没有其它为访问的顶点了,这时队列为空,搜索结束。
代码实现
实现深度优先搜索的栈 StackX.class:
package testOffer.graphpro;
//实现深度优先搜索的栈
public class StackX {
private final int SIZE = 20;
private int[] st;
private int top; public StackX(){
st = new int[SIZE];
top = -1;
} public void push(int j){
st[++top] = j;
} public int pop(){
return st[top--];
} public int peek(){
return st[top];
} public boolean isEmpty(){
return (top==-1);
}
}
实现广度优先搜索的队列Queue.class:
package testOffer.graphpro;
//实现广度优先搜索的队列
public class QueueX {
private final int SIZE = 20;
private int[] queArray;
private int front;
private int rear; public QueueX(){
queArray = new int[SIZE];
front = 0;
rear = -1;
} public void insert(int j){
if (rear == SIZE-1)
rear = -1;
queArray[++rear] = j;
} public int remove(){
int temp = queArray[front++];
if (front == SIZE){
front = 0;
}
return temp;
} public boolean isEmpty(){
return (rear+1 == front || front+SIZE-1 == rear);
} }
图代码 Graph.class:
package testOffer.graphpro; public class Graph {
private final int MAX_VERTS = 20;//表示顶点的个数
private Vertex vertexList[];//用来存储顶点的数组
private int adjMat[][];//用邻接矩阵来存储边,数组元素表示没有边界,1表示有边界
private int nVerts;//顶点个数
private StackX theStack;//用栈实现深度优先搜索
private QueueX queue;//用队列实现广度优先搜索 /**
* 顶点类
* */
class Vertex{
public char label;
public boolean wasVisited;
public Vertex(char label){
this.label = label;
wasVisited = false;
}
} public Graph(){
vertexList = new Vertex[MAX_VERTS];
adjMat = new int[MAX_VERTS][MAX_VERTS];
nVerts = 0;//初始化顶点个数为0
//初始化邻接矩阵所有元素都为0,即所有顶点都没有边
for (int i=0;i<MAX_VERTS;i++){
for (int j=0;j<MAX_VERTS;j++){
adjMat[i][j] = 0;
}
}
theStack = new StackX();
queue = new QueueX();
} //将顶点添加到数组中,是否访问标志置为wasVisited=false(未访问)、
public void addVertex(char lab){
vertexList[nVerts++] = new Vertex(lab);
} //注意用邻接矩阵表示边,是对称的,两部分都要赋值
public void addEdge(int start,int end){
adjMat[start][end] = 1;
adjMat[end][start] = 1;
} //打印某个顶点表示的值
public void displayVertex(int v){
System.out.print(vertexList[v].label+" ");
} /**深度优先搜索算法
* 1、用peek方法检查栈顶的顶点
* 2、用getAdjUnvisitedVertex方法找到当前栈顶邻接且未被访问的顶点
* 3、第二步返回值不等于-1则找到下一个未访问的邻接顶点,访问这个顶点,并入栈
* 如第二步返回值等于-1,则没有找到,出栈
* */
public void depthFirstSearch(){
//从第一个顶点开始访问
vertexList[0].wasVisited = true;//访问之后标记为true
displayVertex(0);
theStack.push(0); while (!theStack.isEmpty()){
//找到栈当前顶点邻接且未被访问的顶点
int v = getAdjUnvisitedVertex(theStack.peek());
if (v==-1){//如果当前顶点值为-1,则表示没有邻接且未被访问的顶点,那么出栈顶点
theStack.pop();
}else {
//否则访问下一个邻接点
vertexList[v].wasVisited = true;
displayVertex(v);
theStack.push(v);
}
} //栈访问完毕,重置所有标记位为false
for (int i=0;i<nVerts;i++){
vertexList[i].wasVisited = false;
}
} //找到与某一顶点邻接且未被访问的顶点
public int getAdjUnvisitedVertex(int v){
for (int i=0;i<nVerts;i++){
//v顶点与i顶点相邻且未被访问
if (adjMat[v][i]==1&&vertexList[i].wasVisited==false)
return i;
}
return -1;
} /**广度优先搜索
* 1、用remove方法检查栈顶的栈顶
* 2、试图找到这个顶点还未被访问的邻接点
* 3、如果没有找到,该顶点出列
* 4、如果找到这样的顶点,访问这个顶点,并把它放入队列中
* */
public void breadthFirstSearch(){
vertexList[0].wasVisited = true;
displayVertex(0);
queue.insert(0);
int v2; while(!queue.isEmpty()){
int v1 = queue.remove();
while ((v2 =getAdjUnvisitedVertex(v1))!=-1){
vertexList[v2].wasVisited = true;
displayVertex(v2);
queue.insert(v2);
}
} //搜索完毕,初始化,便于下次搜索
for (int i=0;i<nVerts;i++){
vertexList[i].wasVisited = false;
}
} public static void main(String[] args) {
Graph graph = new Graph();
graph.addVertex('A');
graph.addVertex('B');
graph.addVertex('C');
graph.addVertex('D');
graph.addVertex('E'); graph.addEdge(0,1);//AB
graph.addEdge(1,2);//BC
graph.addEdge(0,3);//AD
graph.addEdge(3,4);//DE System.out.println("深度优先搜索算法:");
graph.depthFirstSearch(); System.out.println();
System.out.println("---------------"); System.out.println("广度优先搜索算法:");
graph.breadthFirstSearch();
} }
深度优先搜索(DFS)与广度优先搜索(BFS)的Java实现的更多相关文章
- 深度优先搜索DFS和广度优先搜索BFS简单解析(新手向)
深度优先搜索DFS和广度优先搜索BFS简单解析 与树的遍历类似,图的遍历要求从某一点出发,每个点仅被访问一次,这个过程就是图的遍历.图的遍历常用的有深度优先搜索和广度优先搜索,这两者对于有向图和无向图 ...
- 深度优先搜索DFS和广度优先搜索BFS简单解析
转自:https://www.cnblogs.com/FZfangzheng/p/8529132.html 深度优先搜索DFS和广度优先搜索BFS简单解析 与树的遍历类似,图的遍历要求从某一点出发,每 ...
- 图的遍历(搜索)算法(深度优先算法DFS和广度优先算法BFS)
图的遍历的定义: 从图的某个顶点出发访问遍图中所有顶点,且每个顶点仅被访问一次.(连通图与非连通图) 深度优先遍历(DFS): 1.访问指定的起始顶点: 2.若当前访问的顶点的邻接顶点有未被访问的,则 ...
- 深度优先搜索DFS和广度优先搜索BFS
DFS简介 深度优先搜索,一般会设置一个数组visited记录每个顶点的访问状态,初始状态图中所有顶点均未被访问,从某个未被访问过的顶点开始按照某个原则一直往深处访问,访问的过程中随时更新数组visi ...
- 图的深度优先搜索(DFS)和广度优先搜索(BFS)算法
深度优先(DFS) 深度优先遍历,从初始访问结点出发,我们知道初始访问结点可能有多个邻接结点,深度优先遍历的策略就是首先访问第一个邻接结点,然后再以这个被访问的邻接结点作为初始结点,访问它的第一个邻接 ...
- 图的 储存 深度优先(DFS)广度优先(BFS)遍历
图遍历的概念: 从图中某顶点出发访遍图中每个顶点,且每个顶点仅访问一次,此过程称为图的遍历(Traversing Graph).图的遍历算法是求解图的连通性问题.拓扑排序和求关键路径等算法的基础.图的 ...
- 图的深度优先遍历(DFS)和广度优先遍历(BFS)
body, table{font-family: 微软雅黑; font-size: 13.5pt} table{border-collapse: collapse; border: solid gra ...
- 【C++】基于邻接矩阵的图的深度优先遍历(DFS)和广度优先遍历(BFS)
写在前面:本博客为本人原创,严禁任何形式的转载!本博客只允许放在博客园(.cnblogs.com),如果您在其他网站看到这篇博文,请通过下面这个唯一的合法链接转到原文! 本博客全网唯一合法URL:ht ...
- 图的深度优先遍历(DFS)和广度优先遍历(BFS)算法分析
1. 深度优先遍历 深度优先遍历(Depth First Search)的主要思想是: 1.首先以一个未被访问过的顶点作为起始顶点,沿当前顶点的边走到未访问过的顶点: 2.当没有未访问过的顶点时,则回 ...
- 深度优先搜索(DFS)和广度优先搜索(BFS)
深度优先搜索(DFS) 广度优先搜索(BFS) 1.介绍 广度优先搜索(BFS)是图的另一种遍历方式,与DFS相对,是以广度优先进行搜索.简言之就是先访问图的顶点,然后广度优先访问其邻接点,然后再依次 ...
随机推荐
- CUDA编程模型之内存管理
CUDA编程模型假设系统是由一个主机和一个设备组成的,而且各自拥有独立的内存. 主机:CPU及其内存(主机内存),主机内存中的变量名以h_为前缀,主机代码按照ANSI C标准进行编写 设备:GPU及其 ...
- Get,Post请求方式经典详解
本文转自:http://blog.csdn.net/findsafety/article/details/47129021 前几天工作中,所有表单我都采用post方法,头儿说那样不好,大型网站上一般都 ...
- 自动化测试基础二(Python基础)
1.为什么学习Python 1)简单.易学 2)强大:交互性.解释性.编译性.跨平台 3)市场需求上升快.顺应市场需要 4)自动化测试需要使用编程语言来写脚本 2.需要学习Python哪些内容? 1) ...
- 第四天 Java语言基础
一.函数的概念 1)什么函数 函数就是定义在类中的具有特定功能的一段独立小程序,并能被多次使用. 2)问题引入 在昨天讲述使用循环嵌套画出矩形.但有问题,每次要画矩形都要写很多重复性的代码,能不能将这 ...
- kv_storage.go
package storage //kv 存储引擎实现 import ( "github.com/cznic/kv" "io" ) //kv 存 ...
- version.go
package blog4go const ( // 版本号 VERSION = "0.5.6" )
- Nordic nRF51/nRF52开发流程说明
Nordic nRF51系列包括nRF51822/nRF51422/nRF51802等芯片,nRF52系列包括nRF52832/nRF52840/nRF52810等芯片,硬件工程师可以按照如下流程去评 ...
- 二逼平衡树 Tyvj 1730 BZOJ3196 Loj#106
树状数组+主席树,模板题,不多说... #include <cstdio> #include <algorithm> #include <cmath> #inclu ...
- Raft算法
http://www.cnblogs.com/mindwind/p/5231986.html
- React从入门到放弃之前奏(5):ReactRouter4
概念 安装:npm i -S react-router react-router-dom GitHub:ReactTraining/react-router React Router中有三种类型的组件 ...