C++实现图的深度优先遍历和广度优先遍历

最新推荐文章于 2024-02-26 09:39:09 发布
最新推荐文章于 2024-02-26 09:39:09 发布
阅读量2.1k 收藏 13
点赞数 4
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KOwzb/article/details/114328425
版权

图的深度和广度优先遍历

图的深度优先遍历

1、算法思想

  • （1）从图中的某个初始点 v 出发，首先访问初始点 v.
  • （2）选择一个与顶点 v 相邻且没被访问过的顶点 ver ，以 ver为初始顶点，再从它出发进行深度优先遍历。
  • （3）当路径上被遍历完，就访问上一个顶点的第 二个相邻顶点。
  • （4）直到所有与初始顶点 v联通的顶点都被访问。

2、邻接矩阵构造图

#include <iostream>
#include <vector>

using namespace std;

#define VERTEXNUM 5

void createGraph(vector<vector<int>>&edge, int start, int end);
void displayGraph(vector<vector<int>>&edge);
void DFS(vector<vector<int>>&edge , vector<int>& vertexStatusArr);
void DFScore(vector<vector<int>>&edge, int i, vector<int>& vertexStatusArr);

int main(void) {
	
	//初始化邻接矩阵
	vector<vector<int>>edge(VERTEXNUM, vector<int>(VERTEXNUM, 0));
	
	//存放顶点的遍历状态，0：未遍历，1：已遍历  
	vector<int> vertexStatusArr (VERTEXNUM,0);

	cout << "after init: " << endl;
	displayGraph(edge);
	//创建图
	createGraph(edge, 0, 3);
	createGraph(edge, 0, 4);
	createGraph(edge, 3, 1);
	createGraph(edge, 3, 2);
	createGraph(edge, 4, 1);

	cout << "after create: " << endl;
	displayGraph(edge);
	//深度优先遍历
	DFS(edge, vertexStatusArr);

	return 0;
}
//创建图 
void createGraph(vector<vector<int>>&edge, int start, int end) {
	edge[start][end] = 1;
}
//打印存储的图
void displayGraph(vector<vector<int>>&edge) {
	int i, j;
	for (i = 0; i<VERTEXNUM; i++) {
		for (j = 0; j<VERTEXNUM; j++) {
			//printf("%d ", edge[i][j]);
			cout << edge[i][j] << " ";
		}
		cout << endl;
	}
}
//深度优先遍历
void DFS(vector<vector<int>>&edge, vector<int>& vertexStatusArr) {
	cout << "start BFT graph: " << endl;
	for (int i = 0; i<VERTEXNUM; i++) {
		DFScore(edge, i, vertexStatusArr);
	}
	cout << endl;
}
void DFScore(vector<vector<int>>&edge, int i, vector<int>& vertexStatusArr) {
	if (vertexStatusArr[i] == 1) {
		return;
	}
	cout << i << " ";
	vertexStatusArr[i] = 1;

	for (int j = 0; j<VERTEXNUM; j++) {
		if (edge[i][j] == 1) {
			DFScore(edge, j, vertexStatusArr);
		}
	}
}

                                                                     在这里插入图片描述

设有n个点，e条边
邻接矩阵：矩阵包含n ^2个元素，在算法中，共n个顶点，对每个顶点都要遍历n次，所以时间复杂度为O(n^2)

3、邻接表构造图 

#include <stdio.h>
#include <malloc.h>

#define VERTEXNUM 5

//存放顶点的邻接表元素  
typedef struct edge {
	int vertex;
	struct edge* next;
}st_edge;

void createGraph(st_edge** edge, int start, int end);
void displayGraph(st_edge** edge);
void delGraph(st_edge** edge);
void DFT(st_edge** edge, int* vertexStatusArr);
void DFTcore(st_edge** edge, int i, int* vertexStatusArr);

int main(void) {
	//动态创建存放边的指针数组   
	st_edge** edge = (st_edge**)malloc(sizeof(st_edge*)*VERTEXNUM);
	int i;
	for (i = 0; i<VERTEXNUM; i++) {
		edge[i] = NULL;
	}
	//存放顶点的遍历状态，0：未遍历，1：已遍历  
	int* vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);
	for (i = 0; i<VERTEXNUM; i++) {
		vertexStatusArr[i] = 0;
	}

	printf("after init:\n");
	displayGraph(edge);
	//创建图  
	createGraph(edge, 0, 3);
	createGraph(edge, 0, 4);
	createGraph(edge, 3, 1);
	createGraph(edge, 3, 2);
	createGraph(edge, 4, 1);

	printf("after create:\n");
	displayGraph(edge);
	//深度优先遍历 
	DFT(edge, vertexStatusArr);
	//释放邻接表占用的内存  
	delGraph(edge);
	edge = NULL;
	free(vertexStatusArr);
	vertexStatusArr = NULL;
	return 0;
}
//创建图 
void createGraph(st_edge** edge, int start, int end) {
	st_edge* newedge = (st_edge*)malloc(sizeof(st_edge));
	newedge->vertex = end;
	newedge->next = NULL;
	edge = edge + start;
	while (*edge != NULL) {
		edge = &((*edge)->next);
	}
	*edge = newedge;
}
//打印存储的图 
void displayGraph(st_edge** edge) {
	int i;
	st_edge* p;
	for (i = 0; i<VERTEXNUM; i++) {
		printf("%d:", i);
		p = *(edge + i);
		while (p != NULL) {
			printf("%d ", p->vertex);
			p = p->next;
		}
		printf("\n");
	}
}
//释放邻接表占用的内存 
void delGraph(st_edge** edge) {
	int i;
	st_edge* p;
	st_edge* del;
	for (i = 0; i<VERTEXNUM; i++) {
		p = *(edge + i);
		while (p != NULL) {
			del = p;
			p = p->next;
			free(del);
		}
		edge[i] = NULL;
	}
	free(edge);
}
//深度优先遍历 
void DFT(st_edge** edge, int* vertexStatusArr) {
	printf("start BFT graph:\n");
	int i;
	for (i = 0; i<VERTEXNUM; i++) {
		DFTcore(edge, i, vertexStatusArr);
	}
	printf("\n");
}

void DFTcore(st_edge** edge, int i, int* vertexStatusArr) {
	if (vertexStatusArr[i] == 1) {
		return;
	}
	printf("%d ", i);
	vertexStatusArr[i] = 1;
	st_edge* p = *(edge + i);
	while (p != NULL) {
		DFTcore(edge, p->vertex, vertexStatusArr);
		p = p->next;
	}
}

                                                              在这里插入图片描述

 

邻接表：包含n个头结点和e个表结点，算法中对所有结点都要遍历一次，所以时间复杂度为O（n+e）

 图的广度优先遍历

1、算法思想

广度优先遍历( Breadth_First_Search) ，又称为广度优先搜索，简称BFS。

它的思想是：

从图中某顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，
然后分别从这些邻接点出发依次访问它们的邻接点，并使得“先被访问的顶点的邻接点先于后被访问的顶点的邻接点被访问，直至图中所有已被访问的顶点的邻接点都被访问到。
如果此时图中尚有顶点未被访问，则需要另选一个未曾被访问过的顶点作为新的起始点，重复上述过程，直至图中所有顶点都被访问到为止。

                                                                      在这里插入图片描述

2、邻接矩阵构造图

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

#define VERTEXNUM 5

void createGraph(vector<vector<int>>&edge, int start, int end);
void displayGraph(vector<vector<int>>&edge);
void DFS(vector<vector<int>>&edge, vector<int>& vertexStatusArr);
void DFScore(vector<vector<int>>&edge, int i, vector<int>& vertexStatusArr);
void BFS(vector<vector<int>>&edge, vector<int>& vertexStatusArr);

int main(void) {

	//初始化邻接矩阵
	vector<vector<int>>edge(VERTEXNUM, vector<int>(VERTEXNUM, 0));

	//存放顶点的遍历状态，0：未遍历，1：已遍历  
	vector<int> vertexStatusArr(VERTEXNUM, 0);

	cout << "after init: " << endl;
	displayGraph(edge);
	//创建图
	createGraph(edge, 0, 3);
	createGraph(edge, 0, 4);
	createGraph(edge, 3, 1);
	createGraph(edge, 3, 2);
	createGraph(edge, 4, 1);

	cout << "after create: " << endl;
	displayGraph(edge);
	//深度优先遍历
	//DFS(edge, vertexStatusArr);
	BFS(edge, vertexStatusArr);
	return 0;
}
//创建图 
void createGraph(vector<vector<int>>&edge, int start, int end) {
	edge[start][end] = 1;
}
//打印存储的图
void displayGraph(vector<vector<int>>&edge) {
	int i, j;
	for (i = 0; i<VERTEXNUM; i++) {
		for (j = 0; j<VERTEXNUM; j++) {
			//printf("%d ", edge[i][j]);
			cout << edge[i][j] << " ";
		}
		cout << endl;
	}
}

//BFS
void BFS(vector<vector<int>>&edge ,vector<int>& vertexStatusArr) {
	queue<int>q;
	q.push(0);
	vertexStatusArr[0] = 1;
	int idx = 0;
	while (!q.empty())
	{
		idx = q.front();
		q.pop();
		cout << idx << " ";
		for (int j = 0; j< VERTEXNUM; j++) {
			if (edge[idx][j] == 1 && vertexStatusArr[j] == 0)
			{
				q.push(j);
				vertexStatusArr[j] = 1;
			}
		}
	}
	cout << endl;
}

 

                                                                       在这里插入图片描述

 

 

KOwzb
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++实现图的邻接矩阵存储和广度、深度优先遍历实例分析
12-26
本文实例讲述了C++实现图的邻接矩阵存储和广度、深度优先遍历的方法。分享给大家供大家参考。具体如下： 示例：建立如图所示的无向图 由上图知，该图有5个顶点，分别为a,b,c,d,e,有6条边. 示例输入（按照这个格式输入）： 5 6 abcde 0 1 1 0 2 1 0 3 1 2 3 1 2 4 1 1 4 1 输入结束（此行不必输入） 注：0 1 1表示该图的第0个顶点和第1个定点有边相连，如上图中的a->b所示       0 2 1表示该图的第0个顶点和第2个定点有边相连，如上图中的a->c所示       2 3 1表示该图的第2个顶点和第3个定点有边相连，如上图中的c->d所示
C++ 实现图的广度和深度优先遍历
weixin_42356649的博客
10-22 622
广度优先 BFS 广度优先类似于树的的层次遍历，核心用到 队列的思想 深度优先 DFS 深度优先类似于树的先根遍历 ， 核心用到递归的思想 #include <iostream> #define Maxvex 100 #include <queue> bool visited[Maxvex];//在深度优先中是否被遍历过 typedef char VertexType;//...
c++ 广度优先搜索（Breadth-First Search，BFS）
最新发布
csdn_aspnet的专栏
02-26 1247
其基本思想是先访问起始顶点，然后逐层遍历其相邻的顶点，直到找到目标顶点或遍历完所有顶点。BFS算法的时间复杂度用 的形式表示O(V + E)，其中V是节点数，E 是边数。我们从顶点 0 开始，BFS 算法首先将其放入 Visited 列表中，并将其所有相邻顶点放入堆栈中。接下来，我们访问队列前面的元素（即 1）并访问其相邻节点。顶点 2 在 4 中有一个未访问的相邻顶点，因此我们将其添加到队列的后面并访问位于队列前面的 3。队列中只剩下 4 个节点，因为 3 的唯一相邻节点（即 0）已经被访问过。
【C语言】图的深度优先遍历&广度优先遍历(算法，代码一步到位)
Jaye513的博客
12-10 3318
图的两种遍历，你一定要学会
(超详细)C++图的深度优先遍历、广度优先遍历（数据结构）
热门推荐
m0_54158068的博客
04-18 1万+
(超详细)C++图的深度优先遍历、广度优先遍历（数据结构）。根据下图，编写代码实现图的深度优先遍历和广度优先遍历。按照英文字母顺序，以邻接表为存储结构，实现图的深度优先和广度优先遍历。遍历的顺序从顶点a开始。以用户指定的结点为起点，分别输出每种遍历下的结点访问序列。
【c++】图的遍历-深度优先(DFS)与广度优先(BFS)算法分析与实现
Var-al 的博客
02-21 1301
图常用的遍历： 深度优先遍历(Depth_Frist Search – DFS) 广度优先遍历(Breadth_Frist Search – BFS) 深度优先遍历（DFS） 方法： 在访问图中后以起始点v后，由v触发，访问他的任一邻接点w1，然后再从w2出发，进行类似的访问，… 如此进行下去，直到到达所有的邻接顶点都被访问过顶点u位置。 接着，退回一步，退到前一次访问过的顶点，看是否还有其他没有被访问的邻接顶点。 如果有，则访问此顶点，之后再从此顶点出发，进行与前述类似的访问； 如果没有，就
C/C++实现图的深度优先遍历和广度优先遍历
12-26
C/C++实现图的深度优先遍历和广度优先遍历
C++无向图深度优先和广度优先遍历（编译可运行）.rar
07-12
以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。 注： 1.代码共182行。 2.代码经过多次编译运行，无错误。
Graph1_非递归算法进行深度优先遍历和广度优先遍历_
10-02
使用邻接表表示法创建无向图，然后使用非递归算法进行深度优先遍历和广度优先遍历
c++实现图的邻接表深度优先遍历，广度优先遍历
01-20
c++实现图的邻接表深度优先遍历，广度优先遍历
C++实现二叉树的深度优先遍历(DFS)和广度优先遍历(BFS)
Coast_Tt的博客
04-22 2045
对于如下图所示的二叉树： 深度优先遍历：ABDECF 广度优先遍历：ABCDEF #include <iostream> #include <stack> #include <queue> #include <algorithm> using namespace std; struct TreeNode { int val; TreeNode *lchild; TreeNode *rchild; TreeNode(
图的遍历（深度、广度）——C/C++
有人_295的博客
06-30 1万+
图的基础：https://blog.csdn.net/weixin_42109012/article/details/94140343 队列基础：https://blog.csdn.net/weixin_42109012/article/details/92104948 例子： 一、深度优先遍历 1、算法思想 （1）从图中的某个初始点 v 出发，首先访问初始点 v. （2）选择一个与顶点 v 相...
深度优先遍历和广度优先遍历代码实现
ClimberCoding
05-22 2357
图 代码主要参考：https://blog.csdn.net/weixin_40953222/article/details/80544928?spm=1001.2014.3001.5501 1. 什么是图 表示 “多对多” 的关系 包含：1. 一组顶点：通常用V(vertex) 表示顶点集合；2. 一组边：通常用E(edge) 表示边的集合。 边是定点对：(v, w)∈E，其中v, w∈V 有向边<v, w> 表示从 v 指向 w 的边（单行边） 表示方法 邻接矩阵表示法 好
C语言实现图的广度优先搜索遍历和深度优先搜索遍历
我一定要早睡
08-14 712
在这里广度优先遍历没有使用队列而是使用了数组代替了队列，如果使用队列可以使用顺序队列，然后使用入队和出队的代码，在这里数组其实作用差不太多。测试可以按照上一个运行的测试样例对照。
【Dev-c++】C语言数据结构实验——图
m0_52474147的博客
07-25 946
2、实验6.2建立图的邻接存储并在此基础上实现图的深度优先遍历和广度优先遍历。3、理解最小生成树的有关概念及普里姆(Prim)和克鲁斯卡尔算法。1、实验6.1建立无向图的邻接矩阵存并输出。3、保存和截图程序的运行结果，并结合程序进行分析。1、掌握图的基本存储方法和相关术语。2、掌握图的两种搜索路径的遍历方法。4、掌握图的有关应用。2、上机调试，并运行程序。三、实验内容和基本原理。......
c++树与图的深度优先遍历
2301_76180325的博客
05-30 159
深度优先遍历从根节点开始，沿着某个分支尽可能深入地遍历树的节点，直到某个节点无法再拓展下去，然后返回该节点的父节点，继续遍历其他分支，直到遍历整个树或图。对于树或图中的每个节点，深度优先遍历算法都会尽可能深入地搜索该节点的子节点。如果没有子节点或已经遍历了所有子节点，则回溯到该节点的父节点，继续搜索其他的子节点。重心定义：重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。
数据结构-难点代码突破（C++实现图广度优先遍历，深度优先遍历，广度/深度优先遍历生成树和森林，广度优先遍历求单源非带权图两点最短路径）
dodamce的博客
12-18 2564
注意：为了简便起见，这里采用[邻接矩阵](https://blog.csdn.net/dodamce/article/details/128041066?spm=1001.2014.3001.5501)的方式储存图的边信息 @[TOC] 图的遍历是指从图中的某一顶点出发，按照某种搜索方法沿着图中的边对图中的所有顶点访问一次且仅访问一次。 注意到树是一种特殊的图，所以树的遍历实际上也可视为一种特殊的图的遍历。 图的遍历算法是求解图的连通性问题、拓扑排序和求关键路径等算法的基础。 图的遍历比树的遍历
【数据结构】多叉树的深度优先遍历DFS和广度优先遍历BFS（含C++递归和非递归方式实现）
weixin_50941083的博客
05-11 4215
本文主要讲解多叉树的遍历，并附有相关代码。
c++实现图的深度优先遍历和广度优先遍历代码
11-30
以下是C++实现图的深度优先遍历和广度优先遍历的代码： 深度优先遍历： ```c++ #include<iostream> #include<cstring> #include<queue> using namespace std; const int N = 100010; int h[N], e[N], ne[N], idx; bool st[N]; void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ; } void dfs(int u) { st[u] = true; cout << u << " "; for (int i = h[u]; ~i; i = ne[i]) { int j = e[i]; if (!st[j]) dfs(j); } } int main() { memset(h, -1, sizeof h); int n, m, u, v; cin >> n >> m >> u; while (m -- ) { cin >> u >> v; add(u, v); add(v, u); } dfs(u); return 0; } ``` 广度优先遍历： ```c++ #include<iostream> #include<cstring> #include<queue> using namespace std; const int N = 100010; int h[N], e[N], ne[N], idx; bool st[N]; void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ; } void bfs(int u) { queue<int> q; q.push(u); st[u] = true; while (q.size()) { int t = q.front(); q.pop(); cout << t << " "; for (int i = h[t]; ~i; i = ne[i]) { int j = e[i]; if (!st[j]) { q.push(j); st[j] = true; } } } } int main() { memset(h, -1, sizeof h); int n, m, u, v; cin >> n >> m >> u; while (m -- ) { cin >> u >> v; add(u, v); add(v, u); } bfs(u); return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值