基于C语言图的广度优先遍历BFS

最新推荐文章于 2024-03-21 22:16:18 发布
最新推荐文章于 2024-03-21 22:16:18 发布
阅读量514 收藏 3
点赞数 1
文章标签： 数据结构 广度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pdlgyxforever/article/details/126271097
版权

前言

最近在复习数据结构，为了更好的学习，想着在CSDN上分享自己的学习内容，以便更好地掌握知识。

一.图的代码

#include<stdio.h>
#include<stdlib.h>
#define Mvnum 100
#define true 1
#define false 0
#define ok 1
#define error 0
#define infeasible -1
#define overflow -2
typedef int VerTexType;
typedef int Status;
typedef int ArcType;
typedef struct ArcNode{
	int adjvex;
	struct ArcNode* nextarc;
	int info;
}ArcNode;
typedef struct VNode{
	VerTexType data;
	ArcNode *firstarc;
}VNode,AdjList[Mvnum];
typedef struct{
	AdjList vertices;
	int vexnum,arcnum;
}ALGraph;
int Locate(int v,AdjList l,int vexnum){
	int i;
	for(i=0;i<vexnum;i++){
		if(v==l[i].data){
			return i;
		}
	}
	return false;
}
Status CreateUDG(ALGraph *g){
	printf("请输入总顶点数和总边数：\n");
	scanf("%d %d",&(*g).vexnum,&(*g).arcnum);
	int i;
	for(i=0;i<(*g).vexnum;i++){
		printf("请输入第%d个顶点的序号：\n",i+1);
		scanf("%d",&(*g).vertices[i].data);
		(*g).vertices[i].firstarc=NULL;
	}
	for(i=0;i<(*g).arcnum;i++){
		int v1,v2;
		printf("请输入第%d条边的两个顶点：\n",i+1);
		scanf("%d %d",&v1,&v2);
		int i=Locate(v1,(*g).vertices,(*g).vexnum);
		int j=Locate(v2,(*g).vertices,(*g).vexnum);
		ArcNode *p1;
		p1=(ArcNode*)malloc(sizeof(ArcNode));
		p1->adjvex=j;
		p1->nextarc=(*g).vertices[i].firstarc;
		(*g).vertices[i].firstarc=p1; 
		ArcNode *p2;
		p2=(ArcNode*)malloc(sizeof(ArcNode));
		p2->adjvex=i;
		p2->nextarc=(*g).vertices[j].firstarc;
		(*g).vertices[j].firstarc=p2;
	}
	return ok;
}
void Show(ALGraph g){
	int i;
	printf("图的表节点：\n");
	for(i=0;i<g.arcnum;i++){
		printf("%d ",g.vertices[i].data);
	}
	printf("\n图的边节点：\n");
	for(i=0;i<g.vexnum;i++){
		ArcNode *p=g.vertices[i].firstarc;
		while(p){
			printf("%d ",p->adjvex);
			p=p->nextarc;
		}
		printf("\n");
	}
}
int main()
{
	ALGraph g;
	CreateUDG(&g);
	Show(g);
	return 0;
}

图采用邻接表的存储结构

二.队列代码

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
#define true 1
#define false 0
#define ok 1
#define error 0
#define infeasible -1
#define overflow -2
typedef int ElemType;
typedef int Status;
typedef struct{
	ElemType *base;
	int front;
	int rear;
}SqQueue;
Status Init_SqQueue(SqQueue *q,int len){
	q->base=(ElemType*)malloc(sizeof(ElemType)*len);
	if(!q->base){
		exit(overflow);
	}
	q->front=q->rear=0;
	return ok;
}
int Length_SqQueue(SqQueue s){
	return (s.rear-s.front+MAXSIZE)%MAXSIZE;
}
Status IsEmpty_SqQueue(SqQueue s){
	if(s.front==s.rear){
		return ok;
	}
	return error;
}
Status IsFull_SqQueue(SqQueue s){
	if((s.rear+1)%MAXSIZE==s.front){
		return ok;
	}
	return error;
}
Status Destroy(SqQueue *q){
	if(IsEmpty_SqQueue(*q)){
		return error;
	}
	free(q->base);
	q->front=0;
	q->rear=0;
	return ok;
}
Status EnSqQueue(SqQueue *s,ElemType e){
	if(IsFull_SqQueue(*s)){
		return error;
	}
	s->base[s->rear]=e;
	s->rear=(s->rear+1)%MAXSIZE;
	return ok;
}
int DeQueue_SqQueue(SqQueue *s){
	if(IsEmpty_SqQueue(*s)){
		return error;
	}
	int x=s->base[s->front];
	s->front=(s->front+1)%MAXSIZE;
	return x;
}
int GetTop_SqQueue(SqQueue s){
	if(IsEmpty_SqQueue(s)){
		return error;
	}
	return s.base[s.front];
}
Status Clear_SqQueue(SqQueue *s){
	s->front=s->rear=0;
	return ok;
}
int main()
{
	
	return 0;
}

 队列采用循环队列

三.完整代码

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
#define true 1
#define false 0
#define ok 1
#define error 0
#define infeasible -1
#define overflow -2
#define Mvnum 100
typedef int ElemType;
typedef int Status;
typedef int VerTexType;
typedef int Status;
typedef int ArcType;
typedef struct ArcNode{
	int adjvex;
	struct ArcNode* nextarc;
	int info;
}ArcNode;
typedef struct VNode{
	VerTexType data;
	ArcNode *firstarc;
}VNode,AdjList[Mvnum];
typedef struct{
	AdjList vertices;
	int vexnum,arcnum;
}ALGraph;
typedef struct{
	ElemType *base;
	int front;
	int rear;
}SqQueue;
int Locate(int v,AdjList l,int vexnum){
	int i;
	for(i=0;i<vexnum;i++){
		if(v==l[i].data){
			return i;
		}
	}
	return false;
}
Status CreateUDG(ALGraph *g){
	printf("请输入总顶点数和总边数：\n");
	scanf("%d %d",&(*g).vexnum,&(*g).arcnum);
	int i;
	for(i=0;i<(*g).vexnum;i++){
		printf("请输入第%d个顶点的序号：\n",i+1);
		scanf("%d",&(*g).vertices[i].data);
		(*g).vertices[i].firstarc=NULL;
	}
	for(i=0;i<(*g).arcnum;i++){
		int v1,v2;
		printf("请输入第%d条边的两个顶点：\n",i+1);
		scanf("%d %d",&v1,&v2);
		int i=Locate(v1,(*g).vertices,(*g).vexnum);
		int j=Locate(v2,(*g).vertices,(*g).vexnum);
		ArcNode *p1;
		p1=(ArcNode*)malloc(sizeof(ArcNode));
		p1->adjvex=j;
		p1->nextarc=(*g).vertices[i].firstarc;
		(*g).vertices[i].firstarc=p1; 
		ArcNode *p2;
		p2=(ArcNode*)malloc(sizeof(ArcNode));
		p2->adjvex=i;
		p2->nextarc=(*g).vertices[j].firstarc;
		(*g).vertices[j].firstarc=p2;
	}
	return ok;
}
Status Init_SqQueue(SqQueue *q,int len){
	q->base=(ElemType*)malloc(sizeof(ElemType)*len);
	if(!q->base){
		exit(overflow);
	}
	q->front=q->rear=0;
	return ok;
}
int Length_SqQueue(SqQueue s){
	return (s.rear-s.front+MAXSIZE)%MAXSIZE;
}
Status IsEmpty_SqQueue(SqQueue s){
	if(s.front==s.rear){
		return ok;
	}
	return error;
}
Status IsFull_SqQueue(SqQueue s){
	if((s.rear+1)%MAXSIZE==s.front){
		return ok;
	}
	return error;
}
Status Destroy(SqQueue *q){
	if(IsEmpty_SqQueue(*q)){
		return error;
	}
	free(q->base);
	q->front=0;
	q->rear=0;
	return ok;
}
Status EnSqQueue(SqQueue *s,ElemType e){
	if(IsFull_SqQueue(*s)){
		return error;
	}
	s->base[s->rear]=e;
	s->rear=(s->rear+1)%MAXSIZE;
	return ok;
}
int DeQueue_SqQueue(SqQueue *s){
	if(IsEmpty_SqQueue(*s)){
		return error;
	}
	int x=s->base[s->front];
	s->front=(s->front+1)%MAXSIZE;
	return x;
}
int GetTop_SqQueue(SqQueue s){
	if(IsEmpty_SqQueue(s)){
		return error;
	}
	return s.base[s.front];
}
Status Clear_SqQueue(SqQueue *s){
	s->front=s->rear=0;
	return ok;
}
int FirstAdjVex(ALGraph g,int u){
	return g.vertices[u-1].firstarc->adjvex+1;
}
int NextAdjVex(ALGraph g,int u,int w){
	ArcNode *p;
	p=g.vertices[u-1].firstarc;
	while(p&&(p->adjvex+1)!=w){
		p=p->nextarc;
	}
	p=p->nextarc;
	if(p==NULL){
		return -1;
	}
	return p->adjvex+1;
}
void BFS(ALGraph g,int v){
	int visted[g.vexnum+1];
	int i;
	for(i=1;i<=g.vexnum;i++){
		visted[i]=0;
	}
	visted[v]=1;
	SqQueue q;
	Init_SqQueue(&q,g.vexnum);
	EnSqQueue(&q,v);
	while(!IsEmpty_SqQueue(q)){
		int u;
		u=DeQueue_SqQueue(&q);
		printf("%d ",u);
		int w;
		for(w=FirstAdjVex(g,u);w>=0;w=NextAdjVex(g,u,w)){
			if(!visted[w]){
				visted[w]=1;
				EnSqQueue(&q,w);
			}
		}
	}
}
void Show(ALGraph g){
	int i;
	for(i=0;i<g.vexnum;i++){
		printf("\n");
		ArcNode *p=g.vertices[i].firstarc;
		while(p){
			printf("%d ",p->adjvex);
			p=p->nextarc;
		}
	}
}
int main()
{
	ALGraph g;
	CreateUDG(&g);
	Show(g);
	printf("\n");
	BFS(g,1);
	return 0;
}

P.D.L
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
图的邻接矩阵表示，深度优先遍历，广度优先遍历实现
03-13
C++实现，数据结构，图的邻接矩阵表示，深度优先遍历，广度优先遍历，DFS，BFS，为什么要五十个字才能上传啊
C语言寻找无向图两点间的最短路径
12-25
广度优先遍历(BFS)和深度优先遍历(DFS)是图结构中最常用的遍历方式。其中广度优先遍历配合上队列能够找到两点之间的最短路径，同时也能解决一些其他的问题(比如寻找迷宫的最短逃离路线)。广度优先遍历寻找两点之间...
【数据结构】图的广度优先遍历
每天进步一点丶的博客
03-20 1255
文章目录1.算法思想2.定义结构体3.函数实现4.测试结果5.完整代码 1.算法思想 广度优先遍历，类似于树的层次遍历，又是熟悉的队列实现。首先将第一个顶点添加到队列中，然后讲该顶点的所有邻接顶点都加入队列中，再将该顶点输出。如此重复直到遍历完整个图。 2.定义结构体 typedef struct { char vertex[VERTEXNUM]; int edge[VERTEXNUM][VERTEXNUM]; int n,e; } MGraph; 3.函数实现 Q:队列，用于存
图的遍历（深度优先遍历DFS，广度优先遍历BFS）以及Ｃ语言的实现
热门推荐
any_ways的博客
05-01 2万+
遍历的定义： 从已给的连通图中某一顶点出发，沿着一些边访遍图中所有的顶点，且使每个顶点仅被访问一次，就叫做图的遍历，它是图的基本运算． 一:深度优先遍历（ＤＦＳ） １，在访问图中某一起始顶点Ｖ后，由Ｖ出发，访问它的任一邻接顶点Ｗ１ ２，再从Ｗ１出发，访问与Ｗ１邻接但还未被访问过的顶点Ｗ２； ３，然后再从Ｗ２出发，进行类似的访问．．．．．． ４，如此进行下去，直至到达所有的邻接顶点都被访问过的顶点Ｕ为止． ５，接着，退回一步，退到前一次刚访问过的顶点，看是否还有其它没有被访问过的邻接点 ６，如
【C语言】图的广度优先遍历算法
最新发布
csdnabcaq的博客
03-21 364
图的广度优先遍历算法类似与树的层序遍历，都需要借助队列来完成，但不同的是因为图中的数据元素之间的关系是多对多的，所以需要设置访问数组来表示每个数据元素是否被访问过，防止二次访问。即不断遍历访问当前节点及其所有未被访问的邻接点，直至无未被访问结点，再从这些邻接点开始出发遍历。
图的遍历——深度优先搜索（DFS）与广度优先搜索（BFS）（附带C语言源码）
weixin_73602725的博客
05-10 2910
在此之前我们学习过了图的一些基本概念，如同在二叉树中我们有前序遍历，中序遍历，后序遍历一般，在图中也有两种特殊的遍历方式——深度优先遍历与广度优先遍历。
2023-03-31 图的广度优先遍历
lsgwr的博客
03-30 200
下面图的x就是指存储遍历点的容器类型，当是Stack时就是深度优先遍历，当是Queue时就是广度优先遍历，其实也可以是其他的容器类型，比如是个随机弹出的容器类型，那么遍历就相当于是随机遍历了，这个思想在刘老师的《看地见的算法 7个经典应用诠释算法精髓》里有应用到。返回最短路径经过的点和最短路径的值，实际就是加了一个distance数组，记录了BFS过程中经过的点到起点source的距离(无权图默认边长是1，经过一条边加1即可)。代码的图示如下，左侧是DFS的单源路径问题，右侧是BFS的单源路径问题。
数据结构与算法之图的广度优先遍历
five-five
06-14 3800
在学习图的广度优先算法时，需要先学习树的广度优先遍历 (层序遍历，树是一种特殊的图) 5.6 二叉树的层序遍历^a54835 算法存在的问题 改进代码如下： 算法复杂度分析 原理同 代码实现图广度优先遍历 相类似。 广度优先生成树有广度优先遍历过程确定。由于邻接表的表示方式不唯一，因此基于邻接表的广度优先生成树不唯一。 对非连通图的广度优先遍历，可得到广度优先生成森林 思考：......
erchashu.rar_bfs_erchashu_树的 深度优先 广度优先
09-23
本文利用C语言实现了简单的二叉树，每个结点只保存一个整数，并且，由于非常简单，树的根结点是确定的，而不是输入的。...建立好二 叉 树以后，分别利用深度优先（DFS）和广度优先（BFS）进行了遍历，输出结果。
数据结构深度、广度优先搜索算法C语言版
05-20
数据结构课程中的深度优先搜索算法、广度优先搜索算法的C语言程序，在Turbo C 2.0上调试通过。
03邻接矩阵深度和广度遍历DFS_BFS.c
11-01
03邻接矩阵深度和广度遍历DFS_BFS.c
算法数据结构——图的遍历之广度优先搜索算法（Breadth First Search）
白话机器学习
06-06 8170
广度优先搜索算法（Breadth First Search）：简称为 BFS，又译作宽度优先搜索 / 横向优先搜索。是一种用于遍历或搜索树或图的算法。该算法从根节点开始，沿着树的宽度遍历树或图的节点。如果所有节点均被访问，则算法中止。广度优先遍历类似于树的层次遍历过程。呈现出一层一层向外扩张的特点。先看到的节点先访问，后看到的节点后访问。遍历到的节点顺序符合「先进先出」的特点，所以广度优先搜索可以通过「队列」来实现。
图的遍历(广度优先遍历,BFS)
m0_63223213的博客
09-03 4045
广度优先遍历入栈是按照层次将结点进行先后保存，先出栈的也是层数最小的结点，从而实现了广度优先遍历的按层数先后进行访问的要求。因为广度优先遍历操作中需要队列的基本操作，下面的队列（循环队列）为两种图的广度优先遍历共用的。输出： （结点数据为char类型时要注意输入时的空格和换行符的读取问题）图的遍历操作是从图中某一顶点出发，对图中所有顶点访问一次且仅访问一次。（1）在图中，遍历的起始顶点是编号最小的顶点。，将未被访问的邻接点访问并入栈（内层循环）；（2）访问顶点v，顶点v入队列Q；（2）邻接表的广度优先遍历。
C语言经典算法之广度优先遍历算法
weixin_56154577的博客
01-24 1082
图的广度优先遍历（BFS）是一种用于访问和处理图中节点的算法。从起始节点开始，逐层访问节点，先访问离起始节点最近的节点，然后逐层向外扩展。通过队列实现，保证按照广度顺序遍历，用于查找最短路径、连通性检测等。
图的广度优先搜索遍历 -- c语言
qq_43402544的博客
10-31 4697
图的广度优先搜索遍历，以我的理解是：先以一个顶点做起点，一层一层的进行输出打印。 这里引用书上的一个例子。 完整代码如下（邻接表的形式）： #include <stdio.h> #include <stdlib.h> #include <string.h> #define MVNum 100 //最大顶点数 //创建一个中断函数 void Interrupt(void)//创建一个中断函数 { while(1)//用于检测换行符，使函数脱离scanf的连续输出
图的广度优先遍历BFS（C语言）
派拉斯兔子的博客
08-04 3114
一、图的广度优先遍历BFS （一）树 vs 图 ⼴度优先遍历（Breadth-First-Search, BFS）要点： ①、找到与⼀个顶点相邻的所有顶点 ②、标记哪些顶点被访问过 ③、需要⼀个辅助队列 FirstNeighbor(G，x)：求图G中顶点x的第⼀个邻接点，若有则返回顶点号。 若x没有邻接点或图中不存在x，则返回-1。 NextNeighbor(G，x，y)：假设图G中顶点y是顶点x的⼀个邻接点，返回除y之外 顶点x的下⼀个邻接点的顶点号，若y是x的最后⼀个邻接点，则返回-1。 bool
图的深度和广度优先遍历（C语言）
liuchiang03的博客
06-24 6401
图的深度优先遍历和广度优先遍历算法
【C语言】图的深度优先遍历&广度优先遍历(算法，代码一步到位)
Jaye513的博客
12-10 3448
图的两种遍历，你一定要学会
C语言实现深度优先遍历和广度优先遍历
11-28
以下是C语言实现深度优先遍历和广度优先遍历的代码示例： 深度优先遍历： ```c #include #define MAX 100 int visited[MAX]; // 记录节点是否被访问过 int graph[MAX][MAX]; // 存储图的邻接矩阵 int n; // 图中...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值