广度优先搜索

最新推荐文章于 2022-05-11 17:15:04 发布
最新推荐文章于 2022-05-11 17:15:04 发布
阅读量210 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ning_meng_nn/article/details/124334833
版权

c++ 数据结构

广度优先搜索

有点像是树的层次遍历，都需要使用到队列!
在这里插入图片描述

邻接矩阵存储结构无向图——广度优先搜索

#include <iostream>
#include<cmath>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100
//定义无穷大
#define  MAXInt 32767
typedef int Status;
typedef char TElemType;
using namespace std;
//定义顶点数据类型
typedef char VerTexType;
//定义边的数据类型
typedef int ArcType;
//定义图的数据结构
typedef struct {
	//顶点表
	VerTexType vexs[MAXSIZE];
	//邻接矩阵
	ArcType arcs[MAXSIZE][MAXSIZE];
	//当前结点数和当期边数
	int vexnum, arcnum;
}AMGraph; //Adjacency(邻接) Matrix Graph
//函数输入一个顶点的值，返回该顶点在顶点表中的下标，不存在则返回-1
int LocateVex(VerTexType x, AMGraph& G) {
	for (int i = 0; i < G.vexnum; i++)
	{
		if (x == G.vexs[i])
		{
			return i;
		}
	}
	return -1;
}
void createUDN(AMGraph& G) {
	//先输入图的顶点数和边数
	cout << "请输入要创建的无向图的顶点数和边数：" << "\n";
	scanf_s("%d%d", &G.vexnum, &G.arcnum);
	//依次输入各个顶点的值
	cout << "依次输入各个顶点的值" << "\n";
	for (int i = 0; i < G.vexnum; i++) {
		cin >> G.vexs[i];
	}
	//对邻接矩阵进行初始化
	for (int i = 0; i < G.vexnum; i++) {

		for (int j = 0; j < G.vexnum; j++) {
			G.arcs[i][j] = 0;
		}
	}
	cout << "请输入每条边的顶点和权值：输入方式：顶点1 顶点2" << "\n";
	//输入依次输入每一条边的顶点和权值
	for (int i = 0; i < G.arcnum; i++)
	{
		VerTexType a, b;
		cin >> a >> b;
		//找到输入的顶点a，b在顶点表中的下标
		int x = LocateVex(a, G);
		int y = LocateVex(b, G);
		if (x != -1 && y != -1) {
			G.arcs[x][y] = 1;
			G.arcs[y][x] = 1;
		}

	}


}
//输出顶点表以及邻接矩阵
void outPut(AMGraph G) {
	cout << "顶点表如下：" << "\n";
	for (int i = 0; i < G.vexnum; i++) {
		printf("%c ", G.vexs[i]);
	}
	printf("\n输出邻接矩阵如下\n");
	for (int i = 0; i < G.vexnum; i++)
	{
		for (int j = 0; j < G.vexnum; j++)
		{
			printf("%6d", G.arcs[i][j]);
		}
		printf("\n");
	}


}
//定义队列
typedef int QElem;
typedef struct SqQueue {
	QElem* base;
	int front;
	int rear;
};

Status InitQ(SqQueue& q) {
	q.base = new QElem[MAXSIZE];
	if (!q.base)
	{
		return FALSE;
	}
	q.front = q.rear = 0;
	return TRUE;
}
//入队和出队
Status EnQ(SqQueue& q, QElem e) {
	if ((q.rear+1)%MAXSIZE!=q.front)
	{
		q.base[q.rear] = e;
		q.rear = (q.rear + 1) % MAXSIZE;
		return OK;
	}
	return ERROR;
}
Status DeQ(SqQueue& q, QElem& e) {
	if (q.rear==q.front)
	{
		return ERROR;
	}
	e = q.base[q.front];
	q.front = (q.front + 1) % MAXSIZE;
	return OK;
}
bool IsEmpty(SqQueue q) {
	if (q.front==q.rear)
	{
		return true;
	}
	return false;
}

//广度优先遍历,从下标为v的结点开始进行广度优先搜索
int visited[MAXSIZE];
void BFS(AMGraph G,int v) {
	SqQueue q;
	InitQ(q);
	EnQ(q, v);
	visited[v]=1;
	cout << "\n图G的广度搜索为：\n" << "";
	while (!IsEmpty(q))
	{
		int w;
		DeQ(q, w);
		cout << G.vexs[w] << " ";
		//寻找与w下标结点相邻的且未被访问过的结点
		for (int i = 0; i < G.vexnum; i++)
		{
			//这个结点没有被访问过而且和v结点是相邻的
			if (visited[i]==0&&(G.arcs[w][i]!=0))
			{
				visited[i] = 1;
				EnQ(q, i);
			}
		}
	}
}

int main() {
	AMGraph G;
	createUDN(G);
	outPut(G);
	for (int i = 0; i < G.vexnum; i++)
	{
		visited[i] = 0;
	}
	cout << "\n请输入广度优先搜索开始的结点的值：\n" << "";
	VerTexType x;
	cin >> x;
	cout << "\n广度优先搜索遍历的顺序为：" << "\n";
	BFS(G, LocateVex(x, G));
	return 0;
}

邻接表存储结构无向图——广度优先搜索

#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define FALSE 0
#define TRUE 1
#define MAXNum 100
//定义无穷大
#define  MAXInt 32767
typedef int Status;
//定义顶点数据类型
typedef char VerTexType;
//定义节点权重的类型
typedef int OtherInfo;
//定义边的数据类型
typedef struct ArcNode {
	int adjvex;//该边指向的顶点的位置
	ArcNode* nextarc;//指向下一条边的指针
	OtherInfo info;//与边相关的信息
}ArcNode;
//定义表结点的类型
typedef struct VNode {
	VerTexType data;//顶点信息
	ArcNode* firstarc;//指向第一条依附该顶点的边的指针
}VNode, AdjList[MAXNum];//AdjList是邻接表类型
//图结构的类型
typedef struct {
	AdjList vertices;//邻接表
	int vexnum, arcnum;//图当前顶点数和弧数
}ALGraph;//图的定义
//该函数查找顶点x在图的顶点表中的下标
int LocateVex(ALGraph G, VerTexType x) {
	for (int i = 0; i < G.vexnum; i++) {
		if (G.vertices[i].data == x) {
			return i;
		}
	}
	return -1;
}
//邻接表的创建——无向图
Status createUDN(ALGraph& G) {
	cout << "请输入无向图的总结点的数目和总的边数" << "\n";
	cin >> G.vexnum >> G.arcnum;
	cout << "请输入无向图中的各个顶点" << "\n";
	for (int i = 0; i < G.vexnum; i++)
	{
		cin >> G.vertices[i].data;
		//初始化表头结点的指针域
		G.vertices[i].firstarc = NULL;
	}
	cout << "请输入每条边的信息：（顶点1 顶点2）" << "\n";
	for (int i = 0; i < G.arcnum; i++) {
		VerTexType x, y;
		cin >> x >> y;
		//查找两个顶点的下标
		int xIndex = LocateVex(G, x);
		int yIndex = LocateVex(G, y);
		//找到这两个顶点的下标之后就可以往firstarc域插入表结点了
		ArcNode* xArcNode = new ArcNode;
		ArcNode* yArcNode = new ArcNode;
		if (xIndex != -1 && yIndex != -1) {
			//在x结点后面插入邻接y结点的信息
			xArcNode->info = 1;
			xArcNode->adjvex = yIndex;
			xArcNode->nextarc = G.vertices[xIndex].firstarc;
			G.vertices[xIndex].firstarc = xArcNode;
			//在y结点后面插入邻接x结点的信息
			yArcNode->info = 1;
			yArcNode->adjvex = xIndex;
			yArcNode->nextarc = G.vertices[yIndex].firstarc;
			G.vertices[yIndex].firstarc = yArcNode;
		}
		else
		{
			return ERROR;
		}
	}
	return OK;
}

void outPut(ALGraph G) {
	cout << "输出顶点表如下：" << "\n";
	for (int i = 0; i < G.vexnum; i++)
	{
		cout << G.vertices[i].data << " ";
	}
	cout << "\n输入邻接表如下：" << "\n";
	for (int i = 0; i < G.vexnum; i++)
	{
		printf("%c顶点相邻接的顶点为：\n", G.vertices[i].data);
		ArcNode* p = G.vertices[i].firstarc;
		while (p) {
			printf("%c ", G.vertices[p->adjvex].data);
			p = p->nextarc;
		}
		printf("\n");
	}

}
//定义队列
typedef int QElem;
typedef struct SqQueue {
	QElem* base;
	int front;
	int rear;
};

Status InitQ(SqQueue& q) {
	q.base = new QElem[MAXNum];
	if (!q.base)
	{
		return FALSE;
	}
	q.front = q.rear = 0;
	return TRUE;
}
//入队和出队
Status EnQ(SqQueue& q, QElem e) {
	if ((q.rear+1)%MAXNum!=q.front)
	{
		q.base[q.rear] = e;
		q.rear = (q.rear + 1) % MAXNum;
		return OK;
	}
	return ERROR;
}
Status DeQ(SqQueue& q, QElem& e) {
	if (q.rear==q.front)
	{
		return ERROR;
	}
	e = q.base[q.front];
	q.front = (q.front + 1) % MAXNum;
	return OK;
}
bool IsEmpty(SqQueue q) {
	if (q.front==q.rear)
	{
		return true;
	}
	return false;
}

//广度优先遍历,从下标为v的结点开始进行广度优先搜索
int visited[MAXNum];
void BFS(ALGraph G,int v) {
	SqQueue q;
	InitQ(q);
	EnQ(q, v);
	visited[v]=1;
	cout << "\n图G的广度搜索为：\n" << "";
	while (!IsEmpty(q))
	{
		int w;
		DeQ(q, w);
		cout << G.vertices[w].data << " ";
		ArcNode* p = G.vertices[w].firstarc;//获取第一个与w下标结点相邻的结点
		//寻找与w下标结点相邻的且未被访问过的结点
		while (p)
		{
			if (visited[p->adjvex] == 0) {
				EnQ(q, p->adjvex);
				visited[p->adjvex] = 1;//设置p->adjvex下标对应的结点已经被访问
			}
			p = p->nextarc;//查找下一个结点
		}
	}
}

int main() {
	ALGraph G;
	createUDN(G);
	outPut(G);
	for (int i = 0; i < G.vexnum; i++)
	{
		visited[i] = 0;
	}
	cout << "\n请输入广度优先搜索开始的结点的值：\n" << "";
	VerTexType x;
	cin >> x;
	cout << "\n广度优先搜索遍历的顺序为：" << "\n";
	BFS(G, LocateVex(G,x));
	return 0;
}

测试样例：
在这里插入图片描述
邻接矩阵存储方式：
在这里插入图片描述
邻接表存储结构：
在这里插入图片描述

BFS算法效率：

  • 如果使用邻接矩阵，则BFS对于每一个被访问到的顶点，都要循环检测矩阵中的整整一行（n个元素），总的时间代价为O(n2)
  • 如果使用邻接表，虽然有2e个表结点，但自需要扫描e个结点即可完成遍历，加上访问n个头结点的时间，时间复杂度为O（n+e）

DFS和BFS算法比较：

  • 空间复杂度：都是O(n)（借助了堆栈/队列）
  • 时间复杂度只和存储结构（邻接矩阵/邻接表）有关，与搜索路径无关
菜菜iwi
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
广度优先搜索（BFS）和深度优先搜索（DFS）
CODER-GODV的博客
10-23 197
里面的元素是各个结点的信息，元素的内容有数据域，还有边结点类的与表头相连的第一个元素的指针，边结点类包含指向的元素在数组中的秩，下一个边结点的指针，权重，每当表头的链表多增加一个元素，将此元素的指针放在新增加元素的next指针中，然后把该指针设置为表头元素的第一条边。准备一个字符队列存放已经访问过的结点，首先将起点先访问，并且将是否访问的数组置为1，然后再把它推入队列中，依次出队列，然后找到与它相连的结点并且没有被访问过的结点，然后将其访问并把它推入队列,直到队列为空说明所有的结点访问完毕。
图的广度和深度优先路径搜索算法(python实现)
追光少年的博客
07-15 4807
图是一种抽象数据结构，本质和树结构是一样的。图与树相比较，图具有封闭性，可以把树结构看成是图结构的前生。在树结构中，如果把兄弟节点之间或子节点之间横向连接，便构建成一个图。树适合描述从上向下的一对多的数据结构，如公司的组织结构。图适合描述更复杂的多对多数据结构，如复杂的群体社交关系。根据图的特性，图数据结构中至少要包含两类信息所有顶点构成集合信息，这里用V表示（如地图程序中，所有城市构在顶点集合）。所有边构成集合信息，这里用E表示（城市与城市之间的关系描述）。如何描述边？G表示图，则。，...
数据结构之图概念以及深度和广度优先搜索
风间琉璃の博客
05-11 838
1. 图（Graph） 1.1 基础概念 图由**顶点(vertex)和边(edge)**组成，通常表示为G = (V,E)。 其中：G表示一个图，V是顶点集，E是边集。 V有穷且非空。 任意两个顶点之间都可以用边来表示它们之间的关系，E可以是空的。 1.2 有向图（Directed Graph） 边是有明确方向的。 有向无环图（Directed Acyclic Graph，简称 DAG） 如果一个有向图，从任意顶点出发无法经过若干条边回到改顶点，就是一个有向无环图。 出度、入度
广度/宽度优先搜索(BFS)
一米阳光
12-26 3524
raphealguo’blog：http://rapheal.sinaapp.com/2012/08/30/bfs/ 【算法入门】广度/宽度优先搜索(BFS) 发表于 30 八月, 2012 由 raphealguo 1.前言 广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历策略。因为它的思想是从一个顶点V0开始，辐射状
广度优先搜索（BFS）
ZhuRanCheng的博客
04-11 8549
广度优先搜索（BFS） 一、定义  宽度优先搜索(Breadth first Search,BFS),简称宽搜,又称广度优先搜索。它是从初始结点开始,应用产生式规则和控制策略生成第一层结点,同时检查目标结点是否在这些生成的结点中。若没有,再用产生式规则将所有第一层结点逐一拓展,得到第二层结点,并逐一检査第二层结点是否包含目标结点。若没有,再用产生式规则拓展第二层结点。如此依次拓展,检査下去,直至发现目标结点为止。如果拓展完所有结点,都没有发现目标结点,则问题无解。 二、描述 对于以上“无向图”,从顶点.
C++实现广度优先搜索实例
01-01
本文主要叙述了图的遍历算法中的广度优先搜索（Breadth-First-Search）算法，是非常经典的算法，可供C++程序员参考借鉴之用。具体如下： 首先，图的遍历是指从图中的某一个顶点出发，按照某种搜索方法沿着图中的边...
MATLAB源码集锦-基于BFS广度优先搜索算法代码
02-14
其中，BFS（广度优先搜索）是一种常用的策略。本资源“MATLAB源码集锦-基于BFS广度优先搜索算法代码”是专门为MATLAB用户提供的，旨在帮助他们理解和实现BFS算法。 BFS算法的基本思想是从起点开始，首先访问其所有...
python实现广度优先搜索过程解析
09-18
**Python实现广度优先搜索（BFS）过程解析** 广度优先搜索（Breadth-First Search，简称BFS）是一种在图或树结构中进行搜索的算法，它按照从根节点开始，逐层扩展的方式进行。在无权重的图中，BFS通常用于寻找最短...
广度优先搜索求最短路径
07-16
参考中国大学MOOC,计算机算法与程序设计，5.2节内容，实现Python广度优先求最短路径。课程该章节没有课件，我手敲的代码调试好了，供大家一起学习！！！
广度优先搜索 matlab
10-09
广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历策略。本程序用Matlab语言实现广度优先算法
宽度优先搜索 算法.doc
06-09
采用宽度优先搜索算法，编程实现八数码问题的求解。初始状态和目标状态可自定；采用宽度优先搜索算法，编程实现八数码问题的求解。初始状态和目标状态可自定采用宽度优先搜索算法，编程实现八数码问题的求解。初始...
Maze_广度优先搜索_
10-02
在这个场景下，我们使用了"广度优先搜索"（Breadth-First Search，简称BFS）算法来解决这个问题。 广度优先搜索是一种用于遍历或搜索树或图的算法，它的主要思想是从根节点开始，逐层地访问节点的子节点。在图中，...
一看就懂的深度优先搜索和广度优先搜索
weixin_46272350的博客
10-12 1039
什么是搜索算法 算法是作用于具有数据结构之上的，大部分搜索算法是基于“图”这种数据结构。这是因为图的表达能力很强，大部分涉及搜索的场景可以抽象为“图”。 所谓"搜索"，最直接的理解就是，从图中寻找一个顶点出发到另一个顶点的路径。针对不同的需求和场景，对应有不同的算法。 图有两种主要存储方式：邻接表和邻接矩阵。这次我们用邻接表来存储图，用无向图来举例说明。 public class Graph{ //无向图 private int v; //顶点个数 private Linke
【算法入门】广度/宽度优先搜索(BFS)
热门推荐
raphealguo
04-30 17万+
广度/宽度优先搜索(BFS) 【算法入门】 郭志伟@SYSU：raphealguo(at)qq.com 2012/04/27 1.前言 广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历策略。因为它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域，故得名。  一般可以用它做什么呢？一个最直观经典的例子就是走迷宫，我们从起点开始，找出到终点的最

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

菜菜iwi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值