数据结构——详解图的深度优先遍历和广度优先遍历及代码实现

最新推荐文章于 2024-05-21 09:11:55 发布
最新推荐文章于 2024-05-21 09:11:55 发布
阅读量1.3w 收藏 177
点赞数 47
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44244154/article/details/103764328
版权

图的深度优先遍历和广度优先遍历：

从本质上来说都是用来访问图中的所有结点的，只是两种访问的方式不同，深度优先遍历用的是堆栈，先进的后出，而广度优先遍历用的是队列的思想。

1.图的深度优先遍历

1.1基本思想：

⑴ 访问顶点v；
⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；
⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。

例如我们需要用深度优先遍历下面这个图：

首先，我们访问V1结点，V1结点入栈并输出，然后发现V1与V2相连，因此我们将V2入栈，同理，V4和V5也入栈输出，因此遍历序列为V1 V2 V4 V5

在这里插入图片描述

接下来，V5入栈输出后，我们发现与V5相连的两个结点都已经访问过了，因此V5直接出栈，返回到了上一层，即V4，在V4结点处我们发现还有一个结点V8没有被访问到，因此将V8入栈并输出

在这里插入图片描述

同理，V8入栈后会直接出栈，因为与V8相邻的结点都已经被访问过了，接下来V4、V2也出栈，只留下了V1在堆栈中

在这里插入图片描述

这时我们会发现，哎哟，V1还有结点没有访问到哎！哈哈，所以V3、V6、V7相继入栈并输出在这里插入图片描述
最后依次出栈，深度优先就遍历完了！

从顶点v出发图的深度优先遍历算法的伪代码：

  1. 访问顶点v; visited[v] = 1;
  2. w =顶点v的第一个邻接点；
  3. while (w存在)
    3.1 if (w未被访问) 从顶点w出发递归执行该算法;
    3.2 w = 顶点v的下一个邻接点;

1.2深度优先遍历代码实现

在完成深度优先遍历之前，我们首先需要对图进行初始化工作，这儿的图是从文件中直接读取的

template<class DataType>
class MGraph
{
public:
    MGraph();
    ~MGraph(){}
    void DFSTraverse(int v);
    void BFSTraverse(int v);
	int vertexNum,arcNum;//图的顶点数和边数
	DataType vertex[MaxSize];//顶点
private:
    int arc[MaxSize][MaxSize];//图的边长
	bool DFSvisited[MaxSize];//定义一个DFS遍历过标记
	bool BFSvisited[MaxSize];//定义一个BFS遍历过标记
};
template<class DataType>//构造函数
MGraph<DataType>::MGraph()
{
	int i,j;
	fstream fcin_vertex;
	fcin_vertex.open("vertex.txt",ios::in);//打开一个文件用于从文件输入顶点
	vertexNum=0,arcNum=0;//令顶点数、边数赋值为0
    while(!fcin_vertex.eof())
		fcin_vertex>>vertex[vertexNum++];
	fcin_vertex.close();
	memset(DFSvisited,0,sizeof(DFSvisited));//这个函数用来给DFSvisited数组所有成员赋0
	memset(BFSvisited,0,sizeof(BFSvisited));
    for(i=0;i<vertexNum;i++)
        for(j=0;j<vertexNum;j++)
		{
			if(i==j)
				arc[i][j]=0;//如果是相同顶点，则初始化为0
			else
				arc[i][j]=MAX;//否则将边长初始化为MAX;
		}
	fstream fcin_arc;
	fcin_arc.open("arc.txt",ios::in);//打开一个文件用于从文件输入边
	i=0,j=0;
	while(i!=-1)
	{
		fcin_arc>>i;
		if(i==-1)
			continue;
		else
		{
			fcin_arc>>j;
			if(arc[i][j]==0||arc[i][j]==MAX)//如果这条边等于0或者等于MAX,说明这条边还没被修改过，这时候修改一次，边数+1,
				                            //否则，则说明这条边已经被修改过，再修改边数也不会增加
				arcNum++;
			fcin_arc>>arc[i][j];
			arc[j][i]=arc[i][j];//由于是无向图，i到j的距离等于j到i的距离
		}
	}
	fcin_arc.close();
}

接下来是深度优先遍历算法实现：

template<class DataType>
void MGraph<DataType>::DFSTraverse(int v)
{
	int j;
    cout<<vertex[v]<<" ";//遍历到该点，即输出
	DFSvisited[v]=1;//然后将该点的遍历标记置1
    for(j=0;j<vertexNum;j++)
        if(arc[v][j]!=0&&arc[v][j]!=MAX&&DFSvisited[j]==0)//如果边不等于0并且不等于MAX并且该点没有遍历过,就深度优先遍历
			DFSTraverse(j);
}
深度优先遍历也用到了递归的思想，如果边不等于0并且不等于MAX并且该点没有遍历过,就深度优先遍历，再次调用这个函数即可。

2.图的广度优先遍历

2.1基本思想：

⑴ 访问顶点v；
⑵ 依次访问v的各个未被访问的邻接点v1, v2, …, vk；
⑶ 分别从v1，v2，…，vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问。直至图中所有与顶点v有路径相通的顶点都被访问到。

例如还是刚才那个图，我们用广度优先遍历一遍：

在最开始时，V1入列，然后出列输出

在这里插入图片描述

紧接着，与V1相连的结点有V2和V3，因此V2和V3入列并输出

在这里插入图片描述

接下来V2出列，与V2相连的结点有V4和V5，所以V4和V5入列并输出

在这里插入图片描述

接下来同理，V3出列，V6和V7入列并输出

在这里插入图片描述

然后V4出列，与V4相连的还有V8，所以V8入列并输出

在这里插入图片描述

这样就遍历完了，后面的结点由于相邻结点都被访问过了，因此直接出列就完事了

从顶点v出发图的广度优先遍历算法的伪代码：

1. 初始化队列Q;
2. 访问顶点v; visited [v]=1; 顶点v入队列Q;
3. while (队列Q非空) 
    3.1 v=队列Q的队头元素出队;
    3.2 w=顶点v的第一个邻接点;
    3.3 while (w存在) 
          3.3.1 如果w 未被访问，则
                   访问顶点w; visited[w]=1; 顶点w入队列Q；
          3.3.2 w=顶点v的下一个邻接点；

广度优先遍历代码实现：

template<class DataType>//广度优先遍历
void MGraph<DataType>::BFSTraverse(int v)
{
	int Q[MaxSize];
    int front=-1,rear=-1,j;
    cout<<vertex[v]<<" ";//先输出开始广度遍历的结点
	BFSvisited[v]=1;//并把刚才输出的结点标记为1
	Q[++rear]=v;//将该结点入队
    while(front!=rear)//如果队非空
    {
        v=Q[++front];//把队头结点出队，并将出队的结点的数组下标赋给v
        for(j=0;j<vertexNum;j++)//for循环寻找下一个满足  边不等于0并且不等于MAX并且该点没有遍历过  的结点
			if(arc[v][j]!=0&&arc[v][j]!=MAX&&BFSvisited[j]==0)//如果边不等于0并且不等于MAX并且该点没有遍历过
			{
				cout<<vertex[j]<<" ";//输出找到的结点
				BFSvisited[j]=1;//标记置1
				Q[++rear]=j;//结点入队
			}
    }
}

最后给出完整的两种遍历实现的代码

#include<iostream>
using namespace std;
#include<conio.h>//getch()函数头文件
#include<string>//新版vc的getch()函数头文件
#include<stdlib.h>//调节颜色头文件
#include<fstream>
const int MaxSize=100;
const int MAX=10000;//最大距离
template<class DataType>
class MGraph
{
public:
    MGraph();
    ~MGraph(){}
    void DFSTraverse(int v);
    void BFSTraverse(int v);
	int vertexNum,arcNum;//图的顶点数和边数
	DataType vertex[MaxSize];//顶点
private:
    int arc[MaxSize][MaxSize];//图的边长
	bool DFSvisited[MaxSize];//定义一个DFS遍历过标记
	bool BFSvisited[MaxSize];//定义一个BFS遍历过标记
};
template<class DataType>//构造函数
MGraph<DataType>::MGraph()
{
	int i,j;
	fstream fcin_vertex;
	fcin_vertex.open("vertex.txt",ios::in);//打开一个文件用于从文件输入顶点
	vertexNum=0,arcNum=0;//令顶点数、边数赋值为0
    while(!fcin_vertex.eof())
		fcin_vertex>>vertex[vertexNum++];
	fcin_vertex.close();
	memset(DFSvisited,0,sizeof(DFSvisited));//这个函数用来给DFSvisited数组所有成员赋0
	memset(BFSvisited,0,sizeof(BFSvisited));
    for(i=0;i<vertexNum;i++)
        for(j=0;j<vertexNum;j++)
		{
			if(i==j)
				arc[i][j]=0;//如果是相同顶点，则初始化为0
			else
				arc[i][j]=MAX;//否则将边长初始化为MAX;
		}
	fstream fcin_arc;
	fcin_arc.open("arc.txt",ios::in);//打开一个文件用于从文件输入边
	i=0,j=0;
	while(i!=-1)
	{
		fcin_arc>>i;
		if(i==-1)
			continue;
		else
		{
			fcin_arc>>j;
			if(arc[i][j]==0||arc[i][j]==MAX)//如果这条边等于0或者等于MAX,说明这条边还没被修改过，这时候修改一次，边数+1,
				                            //否则，则说明这条边已经被修改过，再修改边数也不会增加
				arcNum++;
			fcin_arc>>arc[i][j];
			arc[j][i]=arc[i][j];//由于是无向图，i到j的距离等于j到i的距离
		}
	}
	fcin_arc.close();
}
template<class DataType>
void MGraph<DataType>::DFSTraverse(int v)
{
	int j;
    cout<<vertex[v]<<" ";//遍历到该点，即输出
	DFSvisited[v]=1;//然后将该点的遍历标记置1
    for(j=0;j<vertexNum;j++)
        if(arc[v][j]!=0&&arc[v][j]!=MAX&&DFSvisited[j]==0)//如果边不等于0并且不等于MAX并且该点没有遍历过,就深度优先遍历
			DFSTraverse(j);
}
template<class DataType>//广度优先遍历
void MGraph<DataType>::BFSTraverse(int v)
{
	int Q[MaxSize];
    int front=-1,rear=-1,j;
    cout<<vertex[v]<<" ";//先输出开始广度遍历的结点
	BFSvisited[v]=1;//并把刚才输出的结点标记为1
	Q[++rear]=v;//将该结点入队
    while(front!=rear)//如果队非空
    {
        v=Q[++front];//把队头结点出队，并将出队的结点的数组下标赋给v
        for(j=0;j<vertexNum;j++)//for循环寻找下一个满足  边不等于0并且不等于MAX并且该点没有遍历过  的结点
			if(arc[v][j]!=0&&arc[v][j]!=MAX&&BFSvisited[j]==0)//如果边不等于0并且不等于MAX并且该点没有遍历过
			{
				cout<<vertex[j]<<" ";//输出找到的结点
				BFSvisited[j]=1;//标记置1
				Q[++rear]=j;//结点入队
			}
    }
}

int main()
{
	MGraph<string> graph;//构造图
	char N;
	int i,j;
	system("color 0A");
	while(true)
	{
		cout<<"请输入需要的功能N："<<endl;
		cout<<"0.退出\n";
		cout<<"1.统计图中边数\n";
		cout<<"2.深度优先遍历\n";
		cout<<"3.广度优先遍历\n";
		cin>>N;
		if(N=='0')break;
		switch(N)
		{
		case '1':
			cout<<"图的边数为:"<<graph.arcNum<<endl;
			cout<<"--请按任意键继续--\n";
			_getch();
			system("CLS");
			break;
		case '2':
			cout<<"图的深度优先遍历结果为:";
			graph.DFSTraverse(0);
			cout<<endl;
			cout<<"--请按任意键继续--\n";
			_getch();
			system("CLS");
			break;
		case '3':
			cout<<"图的广度优先遍历结果为:";
			graph.BFSTraverse(0);
			cout<<endl;
			cout<<"--请按任意键继续--\n";
			_getch();
			system("CLS");
			break;
		default:
			cout<<"输入错误，请重新输入!\n";
			cout<<"--请按任意键继续--\n";
			_getch();
			system("CLS");
		}
	}
	return 0;
}

其中需要读取两个txt文件，一个是图的边信息，另一个是图的顶点信息：

1.图的边信息，文件名命名为arc

0	1	50
0	2	80
1	2	100
1	3	200
2	4	200
3	4	100
3	5	150
4	5	70
4	6	70
5	6	100
5	8	300
6	7	50
8	9	100
8	10	70
8	13	50
9	10	70
10	12	50
10	13	150
12	11	150
12	13	50
13	14	300
13	15	100
-1

2.图的顶点信息，文件名命名为vertex

西街	公寓楼	鸿远楼	修远楼	明远楼	逸夫图书馆	行政楼	南门	树慧园	天行健	澡堂	北门	操场	仙女楼
校医院	东门

运行结果如下：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

诶你爱我吗
关注
  • 47
    点赞
  • 踩
  • 177
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
python基础编程：python实现树的深度优先遍历与广度优先遍历详解
01-20
本文实例讲述了python实现树的深度优先遍历与广度优先遍历。分享给大家供大家参考，具体如下： 广度优先(层次遍历) 从树的root开始，从上到下从左到右遍历整个树的节点 数和二叉树的区别就是，二叉树只有左右两个...
python基础教程：python实现树的深度优先遍历与广度优先遍历详解
12-21
在本文中，我们将深入探讨树的两种主要遍历方法：深度优先遍历（DFS）和广度优先遍历（BFS）。 首先，让我们定义什么是树。树是一种非线性的数据结构，由节点（或称为顶点）和边组成。每个节点可以有零个或多个子...
算法详解——图的深度优先遍历和广度优先遍历
python_plus的博客
03-13 3579
图数据中的深度优先遍历算法和广度优先遍历算法
数据结构学习笔记——图的遍历算法（深度优先搜索和广度优先搜索）
热门推荐
小宇y的博客
08-18 3万+
若通过邻接表表示图，则每个顶点都入队一次，即所需时间为O(|V|)，搜索顶点的邻接顶点所需时间为O(|E|)，其时间复杂度为O(|V|+|E|)。若通过邻接表表示图，则查找所有顶点的邻接顶点所需时间为O(|E|)，访问顶点所需时间为O(|V|)，即总时间复杂度为O(|V|+|E|)。4、查看V7单链表，其邻接顶点为2，即V3，它已经被访问过，于是回到V3单链表，搜索下一个未被访问的邻接顶点；11、查看V8单链表，其邻接顶点为4，即V5，已经被访问过，于是回到V5单链表，搜索下一个未被访问的邻接顶点；....
深度优先搜索遍历与广度优先搜索遍历
最新发布
dfl_xpx的博客
05-21 1037
(2).用邻接表表示图，虽然有2e个表结点，但只需扫描e个结点即可完成遍历，加上访问n个头结点的时间，时间复杂度为O(n+e)一层一层进行访问，广度优先搜索遍历的结果为：V1->C2->V3->V4->V5->V6->V7->V8。(5)4访问6，至此，遍历完所有的点，DFS(深度优先搜索遍历)：2->1->3->5->4->6。(4)到5后，没有可访问的点，返回3，3也没有可访问的点，到1后，可访问之前没有访问过的4。合理的顶点访问次序为：a->c->d->e->f->h->k->b->g。
大话数据结构---（六）图的深度优先遍历和广度优先遍历
松落
03-30 1万+
我们已经掌握了如何存储图中的信息，即邻接矩阵，邻接表，十字链表等。那么我们该如何利用这些存储结构中的数据呢，或者说我该如何找到我想要的数据呢，这里我们就得学会如何遍历图结构，而接下来会和大家介绍两种常用的遍历方法，深度优先遍历和广度优先遍历。
深度优先遍历（DFS）和广度优先遍历（BFS）
wdy00000的博客
03-05 2万+
深度优先遍历（DFS）和广度优先遍历（BFS） 图的遍历：所谓遍历，即是对结点的访问。一个图有多个结点，如何遍历这些结点，有两种访问策略： 深度优先遍历(Depth First Search, 简称 DFS) 广度优先遍历(Breadth First Search 简称 BFS) 开发中广泛用于拓扑排序，寻路(走迷宫)，搜索引擎，爬虫等 一、深度优先遍历 1.1 主要思路 从图中一个未访问的顶点 V 开始，沿着一条路一直走到底，然后从这条路尽头的节点回退到上一个节点，再从另一条路开始走到底
【图论】图的深度优先遍历与广度优先遍历（图文讲解）
qq_49688477的博客
07-24 1万+
一、前言 看懂这篇博客你需要提前知道这些知识点 1.C++链式前向星存图； 2.dfs和bfs是什么以及基本概念； 3.C++STL中的queue，队列数据结构的简单知识点； 4.有关图的一些简单的概念； 图论是一个很重要的知识块，在学习如何遍历图之前，我们首先当然得知道要怎样去建图。在下面的内容里，我们将使用链式前向星来建图，如果对建图有什么问题的话可以移步这篇博客来学习。 链式前向星 在了解建图的方法后，我们当然要开始考虑如何遍历图中的每一个点，在这里，我们将使用两种最基础的遍历方式-----深度优先搜
图的遍历-深度优先遍历与广度优先遍历（C语言）
偶然路过的帅小伙z的博客
04-02 5224
目录 邻接矩阵及邻接表的创建 深度优先遍历（DFS） 邻接矩阵的深度优先遍历 结构定义 邻接矩阵的深度优先遍历操作 邻接矩阵的深度优先递归算法 邻接表的深度优先遍历 结构定义 邻接表的深度优先遍历操作 邻接表的深度优先递归算法 广度优先遍历（BFS） 邻接矩阵的广度遍历 结构定义 邻接矩阵的广度遍历算法 邻接表的广度优先遍历 结构定义 邻接表的遍历算法 广度优先遍历所需队列代码
python实现树的深度优先遍历与广度优先遍历详解
09-18
本篇文章将深入探讨两种主要的树遍历方法：深度优先遍历（DFS，Depth-First Search）和广度优先遍历（BFS，Breadth-First Search），并介绍如何在Python中实现它们。 **深度优先遍历** 是一种沿着树的深度尽可能深...
PHP实现二叉树深度优先遍历(前序、中序、后序)和广度优先遍历(层次)实例详解
10-18
二叉树遍历是访问树中所有节点的一种方法，通常分为深度优先遍历（DFS，Depth-First Search）和广度优先遍历（BFS，Breadth-First Search）。在PHP中，我们可以使用递归或非递归的方式来实现这些遍历算法。 1. 深度...
图的深度、广度优先遍历（c语言）
12-20
本程序方便的实现了图的深度、广度优先遍历。是数据结构中的一部分，现与大家分享
图的遍历（深度优先和广度优先遍历算法）
04-18
图作为较为复杂的数据结构，对图的操作首先应该了解图的深度优先和广度优先搜索遍历算法！
数据结构图的遍历源代码（深度和广度优先）
06-29
数据结构邻接矩阵广度优先搜索，无向图临界表广度优先搜索！
DFS 图的深度优先遍历
12-22
通过DFS算法对图进行深度优先算法遍历，并输出遍历结果
python数据结构之图深度优先和广度优先实例详解
09-21
在Python编程中，数据结构是实现复杂算法的基础，其中图是一种重要的抽象数据类型，用于表示对象之间的关系。...通过理解这些算法的原理和实现，开发者可以更好地利用Python进行图形数据的处理和分析。
图的深度优先遍历及广度优先遍历
weixin_54950870的博客
09-20 7378
图的引出：前面我们学了线性表和树。线性表局限于一个直接前驱和一个直接后继的关系；树也只能有一个直接前驱也就是父结点。但我们需要表示多对多的关系时，我们就需要用到图这种数据结构。 图的表示方式有两种：二维数组表示（邻接矩阵）；链表表示（邻接表）。 邻接矩阵中，如果两个顶点相连通，则为1，如果不连通，则为零。 图的遍历： 有两种策略。1、深度优先遍历（Depth First Search）。2、广度优先遍历（Broad First Search）。 深度优先遍历思想：深度优先遍历是一种纵向切入..
【数据结构】图的遍历：广度优先（BFS），深度优先（DFS）
小人物，大梦想！
09-21 4669
算法思想，广度优先生成树，深度优先生成树，算法实现
图的常用遍历——广度优先遍历和深度优先遍历
kxbdys的博客
05-05 6732
一、遍历图可能遇到的问题 图的特点： 图中可能存在回路，且图的任一顶点都可能与其它顶点相通，在访问完某个顶点之后可能会沿着某些边又回到了曾经访问过的顶点。怎样避免重复访问? 解决思路:设置辅助数组visited[n]，用来标记每个被访问过的顶点。初始状态visited [i]为0 顶点i被访问，改visited [i]为1，防止被多次访问。 二、图的常用遍历 1、深度优先搜索（DFS） 2、广度优先搜索（BFS） 三、深度优先遍历（DFS） 1、遍历的方法 ■在访问图中某一起始顶点V后.
图的遍历与最小生成树.docx
03-13
对于图的遍历，深度优先遍历和广度优先遍历是常用的算法，能够帮助人们更好地理解图的结构和性质。而最小生成树算法则可以在需要构建连通图的应用场景中发挥重要作用，如通信网络的设计、电路板的布线等。通过对图的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值