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

最新推荐文章于 2024-08-18 17:46:51 发布
最新推荐文章于 2024-08-18 17:46:51 发布
阅读量2.3k 收藏 17
点赞数 6
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 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
关注
专栏目录
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++图的深度优先遍历、广度优先遍历（数据结构）
热门推荐
m0_54158068的博客
04-18 2万+
(超详细)C++图的深度优先遍历、广度优先遍历（数据结构）。根据下图，编写代码实现图的深度优先遍历和广度优先遍历。按照英文字母顺序，以邻接表为存储结构，实现图的深度优先和广度优先遍历。遍历的顺序从顶点a开始。以用户指定的结点为起点，分别输出每种遍历下的结点访问序列。
数据结构：二叉树的广度优先遍历与深度优先遍历（递归方法）。C++及其新特性分别实现
最新发布
Mitos的博客
08-18 1223
在二叉树的遍历中，广度优先遍历（BFS）和深度优先遍历（DFS）是两种常用的遍历方法。它们的遍历顺序和实现方法有所不同。以下是这两种遍历方法的详细解释和 C++ 实现
图的遍历（深度、广度）——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 相...
深度优先遍历与广度优先遍历
weixin_34068198的博客
07-18 631
深度优先遍历 1．深度优先遍历的递归定义 　　假设给定图G的初态是所有顶点均未曾访问过。在G中任选一顶点v为初始出发点(源点)，则深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。若此时图中仍有未访...
C/C++实现图的深度优先遍历和广度优先遍历
12-26
C/C++实现图的深度优先遍历和广度优先遍历
Graph1_非递归算法进行深度优先遍历和广度优先遍历_
10-02
本话题主要探讨如何使用非递归算法对无向图进行深度优先遍历（DFS, Depth First Search）和广度优先遍历（BFS, Breadth First Search），这两种遍历方法在图算法中有着广泛的应用。 **1. 邻接表表示法** 在处理大...
无向图建立、深度优先遍历和广度优先遍历实现算法[借鉴].pdf
10-14
在本文中，我们使用递归函数来实现深度优先遍历。递归函数的基本思想是从某个顶点开始，访问该顶点，然后递归访问其相邻的顶点，直到所有顶点都被访问过为止。 三、广度优先遍历 广度优先遍历（Breadth-First ...
C++无向图深度优先和广度优先遍历（编译可运行）.rar
07-12
以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。 注： 1.代码共182行。 2.代码经过多次编译运行，无错误。
数据结构-难点代码突破（C++实现图广度优先遍历，深度优先遍历，广度/深度优先遍历生成树和森林，广度优先遍历求单源非带权图两点最短路径）
dodamce的博客
12-18 2735
注意：为了简便起见，这里采用[邻接矩阵](https://blog.csdn.net/dodamce/article/details/128041066?spm=1001.2014.3001.5501)的方式储存图的边信息 @[TOC] 图的遍历是指从图中的某一顶点出发，按照某种搜索方法沿着图中的边对图中的所有顶点访问一次且仅访问一次。 注意到树是一种特殊的图，所以树的遍历实际上也可视为一种特殊的图的遍历。 图的遍历算法是求解图的连通性问题、拓扑排序和求关键路径等算法的基础。 图的遍历比树的遍历
C++ 实现图的广度和深度优先遍历
weixin_42356649的博客
10-22 667
广度优先 BFS 广度优先类似于树的的层次遍历，核心用到 队列的思想 深度优先 DFS 深度优先类似于树的先根遍历 ， 核心用到递归的思想 #include <iostream> #define Maxvex 100 #include <queue> bool visited[Maxvex];//在深度优先中是否被遍历过 typedef char VertexType;//...
数据结构——深度优先遍历、广度优先遍历 C++实现（含实例代码以及详细注解以及测试数据）
weixin_52009798的博客
12-03 3513
数据结构——深度优先遍历、广度优先遍历 C++实现，已经理解了深度优先和广度优先的相关概念和思路，但是缺少相关代码和使用的实例
C++(数据结构与算法):57---图的遍历（广度优先搜索(BFS)、深度优先搜索(DFS)）
董哥的黑板报
03-12 1540
待续
【c++】图的遍历-深度优先(DFS)与广度优先(BFS)算法分析与实现
Var-al 的博客
02-21 1352
图常用的遍历： 深度优先遍历(Depth_Frist Search – DFS) 广度优先遍历(Breadth_Frist Search – BFS) 深度优先遍历（DFS） 方法： 在访问图中后以起始点v后，由v触发，访问他的任一邻接点w1，然后再从w2出发，进行类似的访问，… 如此进行下去，直到到达所有的邻接顶点都被访问过顶点u位置。 接着，退回一步，退到前一次访问过的顶点，看是否还有其他没有被访问的邻接顶点。 如果有，则访问此顶点，之后再从此顶点出发，进行与前述类似的访问； 如果没有，就
C++实现二叉树的深度优先遍历(DFS)和广度优先遍历(BFS)
Coast_Tt的博客
04-22 2152
对于如下图所示的二叉树： 深度优先遍历：ABDECF 广度优先遍历：ABCDEF #include <iostream> #include <stack> #include <queue> #include <algorithm> using namespace std; struct TreeNode { int val; TreeNode *lchild; TreeNode *rchild; TreeNode(
【C语言】图的深度优先遍历&广度优先遍历(算法，代码一步到位)
Jaye513的博客
12-10 4013
图的两种遍历，你一定要学会
图的创建以及深度与广度优先遍历C/C++
g15827636417的博客
11-05 8099
一、图的存储结构 图有几种最常见的存储结构：邻接矩阵、邻接表和十字链表。 下面仅以邻接表表示法进行图的操作 邻接表： 邻接表（Adjacency List）是一种顺序存储结构与链式存储相结合的图的存储方法。邻接表类似于树的孩子链表表示法。就是对于图G中的每个Vi，将所有邻接于Vi的顶点Vj链成一个单链表，这个单链表就称为顶点Vi的邻接表，再将所有点的邻接表表头放到数组中，就构成了图的邻接表。
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、付费专栏及课程。

余额充值