C语言-广度优先遍历

最新推荐文章于 2024-09-04 07:00:00 发布
最新推荐文章于 2024-09-04 07:00:00 发布
阅读量1.4w 收藏 325
点赞数 50
分类专栏： 数据结构 文章标签： 队列 数据结构 c语言 图论 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/attract1206/article/details/106556607
版权
  1. 图的基本操作
  • 查找函数（LocateVex查找坐标）
  • 构建无向图（Undirected Graph）
  • 输出邻接矩阵（print）
  1. 循环队列基本操作
  • 入队（EnQueue）
  • 出队（DeQueue）
  • 判断队是否为空（QueueEmpty）
  1. 广度优先遍历：
  • 广度优先查找（BFS）
  • 广度优先遍历（BFSTraverse）

广度优先遍历基本步骤

  1. 设置全局变量visited数组并初始化为全0，代表所有节点均未被访问
  2. 设置起始点：包括对起始点进行输出、标记成已访问、入队
  3. 对后续结点进行操作：由起始点开始，对后续结点进行操作（输出、标记成已访问、入队）
    （步骤2-3为广度优先搜索）
  4. 循环重复2-3的操作避免有“孤岛”结点被遗漏。
    （步骤4 循环执行广度优先搜索避免遗漏“孤岛”结点，就是广度优先遍历）

广度优先算法分析

  1. 设定好起始点后，将起始点入队。（下代码第7-10行）
  2. 然后就是对队列进行操作了：每一个元素出队，就要将它的所有邻接点依次入队，每出一次队，就对出队元素进行操作（操作表示找到与该端点有边的端点，进行“输出，设置成已访问，入队”）直到队列为空。
void BFS(MGraph *G,int i)
{
	int j;
	CyQueue q;
	create(&q);
	
    //1.设置起始点 
	printf("%c",G->Vertex[i]);//1.输出起始结点 
	visited[i]=1;//2.将已访问的结点标志成1
	EnQueue(&q,i);//3.将第一个结点入队 

    //2.由起始点开始，对后续结点进行操作 
	while(!QueueEmpty(&q))//队列非空
	{
		
		DeQueue(&q,&i);	
		for(j=0;j<G->vexnum;j++)
		{
			if(G->AdjMatrix[i][j]==1&&visited[j]==0)
			{
				printf("%c",G->Vertex[j]);//输出符合条件的顶点 
	            visited[j]=1;//设置成已访问状态1 
	            EnQueue(&q,j);//入队 
			}
		}
	} 	
}

完整源代码

1.邻接矩阵

#include <stdio.h>
#include <stdlib.h>
#define VertexMax 100 //最大顶点数为100
#define Maxsize 100 //队列最大元素个数100 

typedef char VertexType; //每个顶点数据类型为字符型 
typedef int dataType; //队列元素类型 

/*图结构体*/
typedef struct
{
	VertexType Vertex[VertexMax];//存放顶点元素的一维数组 
	int AdjMatrix[VertexMax][VertexMax];//邻接矩阵二维数组 
	int vexnum,arcnum;//图的顶点数和边数  
}MGraph;

/*队列结构体*/
typedef struct
{
	dataType *base;
	int front;
	int rear;
}CyQueue;
 
/*无向图UDG的基本操作*/
int LocateVex(MGraph *G,VertexType v)//查找元素v在一维数组 Vertex[] 中的下标，并返回下标 
{
	int i;
	
	for(i=0;i<G->vexnum;i++)
	{
		if(v==G->Vertex[i])
		{
			return i; 
		} 
	 } 
	 
	 printf("No Such Vertex!\n");
	 return -1;
}

void CreateUDG(MGraph *G) 
{
	int i,j;

	printf("输入顶点个数和边数：\n");
	printf("顶点数 n="); 
	scanf("%d",&G->vexnum);
	printf("边  数 e="); 
	scanf("%d",&G->arcnum);
	printf("\n"); 
	
	printf("\n");
	

	printf("输入顶点元素(无需空格隔开)：");
	scanf("%s",G->Vertex);
	printf("\n");

	for(i=0;i<G->vexnum;i++) 
	 for(j=0;j<G->vexnum;j++)
	    {
	    	G->AdjMatrix[i][j]=0;
		}
	

	 int n,m;
	 VertexType v1,v2;
	 
	 printf("请输入边的信息：\n");
	 for(i=0;i<G->arcnum;i++)
	 {
	 	printf("输入第%d条边信息：",i+1);
	 	scanf(" %c%c",&v1,&v2);
	 	n=LocateVex(G,v1); 
	 	m=LocateVex(G,v2); 
	 	
	 	if(n==-1||m==-1)
		 {
		 	printf("NO This Vertex!\n");
		 	return;
		  } 
	
	   G->AdjMatrix[n][m]=1;
	   G->AdjMatrix[m][n]=1;
	 } 
	 
}

void print(MGraph G)
{
	int i,j;
	printf("\n-------------------------------");
	printf("\n 邻接矩阵：\n\n"); 	

		printf("\t ");
	    for(i=0;i<G.vexnum;i++)
		printf("  %c",G.Vertex[i]);
		printf("\n");
		 
		for(i=0;i<G.vexnum;i++)
	   {
	   	  printf("\t%c",G.Vertex[i]);
	   	
		  for(j=0;j<G.vexnum;j++)
	    {
	 	    printf("  %d",G.AdjMatrix[i][j]);
	    }
	        printf("\n");
	   }
}

/*循环队列基本操作*/
void create(CyQueue *q)
{
	q->base=(dataType *)malloc(Maxsize*sizeof(dataType));
	if(!q->base)
	{
		printf("Space allocation failed!\n");
		return;
	}
	q->front=q->rear=0;
	return;
}

void EnQueue(CyQueue *q,dataType value)
{
	if((q->rear+1)%Maxsize==q->front)
	{
		printf("Cyclic Queue is Full!\n");
		return;
	}
	q->base[q->rear]=value;
	q->rear=(q->rear+1)%Maxsize;
	return;
}

void DeQueue(CyQueue *q,dataType *value)
{
	if(q->front==q->rear)
	{
		printf("Cyclic Queue is Empty!\n");
		return;
	}
	*value=q->base[q->front];
	q->front=(q->front+1)%Maxsize;
	return;
} 

int QueueEmpty(CyQueue *q)
{
    if (q->front==q->rear)//队列为空返回1，不为空返回0 
	{
        return 1;
    }
    return 0;
}

/*广度优先遍历BFS*/ 
int visited[VertexMax];//定义"标志"数组为全局变量 

void BFS(MGraph *G,int i)
{
	int j;
	CyQueue q;
	create(&q);
   //1.设置起始点 
	printf("%c",G->Vertex[i]);//1.输出当前结点 
	visited[i]=1;//2.将已访问的结点标志成1
	EnQueue(&q,i);//3.将第一个结点入队 
    
    //2.由起始点开始，对后续结点进行操作
	while(!QueueEmpty(&q))
	{
		
		DeQueue(&q,&i);
		
		for(j=0;j<G->vexnum;j++)
		{
			if(G->AdjMatrix[i][j]==1&&visited[j]==0)
			{
				printf("%c",G->Vertex[j]);//输出符合条件的顶点 
	            visited[j]=1;//设置成已访问状态1 
	            EnQueue(&q,j);//入队 
			}
		}
	} 	
} 

void BFSTraverse(MGraph *G)
{
	int i;
	
	//数组初始化为全0 
	for(i=0;i<G->vexnum;i++)
	{
		visited[i]=0;
	} 
	
	for(i=0;i<G->vexnum;i++)
	{
		if(visited[i]==0)
		{
			BFS(G,i);
		}
	}
} 

int main() 
{
	MGraph G; 
	CreateUDG(&G);
	print(G); 
	
	printf("\n\n广度优先遍历："); 
	BFSTraverse(&G); 
	 
	return 0;
}

2.邻接表：

#include <stdio.h>
#include <stdlib.h>
#define VertexMax 20 //最大顶点个数 
#define Maxsize 100 //队列最大元素个数100 

typedef char VertexType;//顶点的数据类型（char）
typedef int dataType; //队列元素类型 

/*邻接表结构体*/
typedef struct ArcNode//边表 
{
	int adjvex;//存储的是该顶点在顶点数组即AdjList[]中的位置 
	struct ArcNode *next;
}ArcNode;

typedef struct VNode //顶单个点 
{
	VertexType vertex;
	struct ArcNode *firstarc;
}VNode;

typedef struct //顶点表 
{
	VNode AdjList[VertexMax];//由顶点构成的结构体数组 
	int vexnum,arcnum; //顶点数和边数 
}ALGraph;

/*循环队列结构体*/
typedef struct
{
	dataType *base;
	int front;
	int rear;
}CyQueue;

/*无向图UDG基本操作*/
int LocateVex(ALGraph *G,VertexType v)
{    
    int i;
	for(i=0;i<G->vexnum;i++)
	{
		if(v==G->AdjList[i].vertex)
		{
			return i;
		}
	}
	
	printf("No Such Vertex!\n");
	return -1;
}

//2.无向图 
void CreateUDG(ALGraph *G)
{
	int i,j;
	//1.输入顶点数和边数
	printf("输入顶点个数和边数：\n");
	printf("顶点数 n="); 
	scanf("%d",&G->vexnum);
	printf("边  数 e="); 
	scanf("%d",&G->arcnum);
	printf("\n"); 
	
	printf("\n");
	//2.顶点表数据域填值初始化顶点表指针域
	printf("输入顶点元素(无需空格隔开)：");
	for(i=0;i<G->vexnum;i++)
	{
		scanf(" %c",&G->AdjList[i].vertex);
		G->AdjList[i].firstarc=NULL;
	} 
	printf("\n");
	
	//3.输入边信息构造邻接表
	int n,m;
	VertexType v1,v2;
	ArcNode *p1,*p2; 
	
	printf("请输入边的信息：\n\n"); 
	for(i=0;i<G->arcnum;i++)
	{   //输入边信息，并确定v1和v2在G中的位置，即顶点在AdjList[]数组中的位置（下标） 
		printf("输入第%d条边信息：",i+1); 
		scanf(" %c%c",&v1,&v2);
		n=LocateVex(G,v1);
		m=LocateVex(G,v2);
		
		if(n==-1||m==-1)
		 {
		 	printf("NO This Vertex!\n");
		 	return;
		  } 
		
		p1=(ArcNode *)malloc(sizeof(ArcNode));
		p1->adjvex=m;//填上坐标 
		p1->next=G->AdjList[n].firstarc;//改链（头插法） 
		G->AdjList[n].firstarc=p1;
		
		p2=(ArcNode *)malloc(sizeof(ArcNode));//无向图的对称 
		p2->adjvex=n;
		p2->next=G->AdjList[m].firstarc;
		G->AdjList[m].firstarc=p2;
		
	}//for 

} 

void print(ALGraph G)
{
	int i;
	ArcNode *p;
	printf("\n-------------------------------");
	printf("\n图的邻接表表示：\n");
	
	for(i=0;i<G.vexnum;i++)
	{
		printf("\n   AdjList[%d]%4c",i,G.AdjList[i].vertex);
		p=G.AdjList[i].firstarc;
		
		while(p!=NULL)
		{
			printf("-->%d",p->adjvex);
			p=p->next;
		}
	 } 
	 printf("\n");
} 

/*循环队列基本操作*/
void create(CyQueue *q)
{
	q->base=(dataType *)malloc(Maxsize*sizeof(dataType));
	if(!q->base)
	{
		printf("Space allocation failed!\n");
		return;
	}
	q->front=q->rear=0;
	return;
}

void EnQueue(CyQueue *q,dataType value)
{
	if((q->rear+1)%Maxsize==q->front)
	{
		printf("Cyclic Queue is Full!\n");
		return;
	}
	q->base[q->rear]=value;
	q->rear=(q->rear+1)%Maxsize;
	return;
}

void DeQueue(CyQueue *q,dataType *value)
{
	if(q->front==q->rear)
	{
		printf("Cyclic Queue is Empty!\n");
		return;
	}
	*value=q->base[q->front];
	q->front=(q->front+1)%Maxsize;
	return;
} 

int QueueEmpty(CyQueue *q)
{
    if (q->front==q->rear)//队列为空返回1，不为空返回0 
	{
        return 1;
    }
    return 0;
}


/*广度优先遍历*/
int visited[VertexMax]; //定义数组为全局变量 

void BFS(ALGraph *G,int i)
{
	int j;
	struct ArcNode *p;
	CyQueue q;
	create(&q);
	
    //1.设置起始点
	printf("%c",G->AdjList[i].vertex);//1.输出起始结点
	visited[i]=1;//2.将已访问的结点标志成1
	EnQueue(&q,i);//3.将第一个结点入队 

    //2.由起始点开始，对后续结点进行操作
	while(!QueueEmpty(&q))
	{
		p=G->AdjList[i].firstarc;
		
		DeQueue(&q,&i);
		while(p!=NULL)
		{
			
			if(visited[p->adjvex]==0)
			{
				printf("%c",G->AdjList[p->adjvex].vertex);
	            visited[p->adjvex]=1;
	            EnQueue(&q,p->adjvex);
			}
			p=p->next;//查找完之后，将p向后推一位 
		}
	} 	
} 

void BFSTraverse(ALGraph *G)
{
	int i;
	
	//数组初始化为全0 
	for(i=0;i<G->vexnum;i++)
	{
		visited[i]=0;
	} 
	
	for(i=0;i<G->vexnum;i++)
	{
		if(visited[i]==0)
		{
			BFS(G,i);
		}
	}
} 

int main() 
{
	ALGraph G; 
	CreateUDG(&G);
	print(G); 
	
	printf("\n\n广度优先遍历："); 
	BFSTraverse(&G); 
	 
	return 0;
}

执行结果

  • 邻接矩阵
    在这里插入图片描述
  • 邻接表
    在这里插入图片描述
Attract1206
关注
专栏目录
数据结构（廿五） -- C语言版 -- 图 - 图的遍历 -- 邻接矩阵 - 深度/广度优先遍历/搜索（DFS、BFS）
青椒*^_^*凤爪爪的博客
12-08 6521
图是一种非线性的数据结构，图的遍历指的是：从图中的某一顶点出发，沿着一些边访问图中所有的顶点，使得每个顶点都被访问且仅被访问一次。根据遍历路径的不同，通常有两种遍历图的方法：深度优先遍历(Depth First Search)和广度优先遍历(Breadth First Search)。它们对无向图和有向图都适用，图的遍历算法是求解图的连通性问题、拓扑排序和求关键路径等算法的基础。
数据结构（廿六） -- C语言版 -- 图 - 图的遍历 -- 邻接表 - 深度/广度优先遍历/搜索（DFS、BFS）
青椒*^_^*凤爪爪的博客
12-19 5253
图是一种非线性的数据结构，图的遍历指的是：从图中的某一顶点出发，沿着一些边访问图中所有的顶点，使得每个顶点都被访问且仅被访问一次。根据遍历路径的不同，通常有两种遍历图的方法：深度优先遍历(Depth First Search)和广度优先遍历(Breadth First Search)。它们对无向图和有向图都适用，图的遍历算法是求解图的连通性问题、拓扑排序和求关键路径等算法的基础。
图的深度、广度优先遍历（c语言）
12-20
本程序方便的实现了图的深度、广度优先遍历。是数据结构中的一部分，现与大家分享
彻底学懂BFS广度优先遍历（最全解）
最新发布
2301_80636070的博客
09-04 3166
广度优先遍历（Breadth-First Search，BFS）是一种图形搜索算法，从图的某一特定顶点出发，首先访问其所有邻接顶点，然后再依次访问这些邻接顶点的邻接顶点，如此一层一层地向外扩展，直到访问完所有顶点。在二叉树等数据结构中，BFS 通常按照从根节点开始，一层一层地横向遍历节点。
C语言经典算法之广度优先遍历算法
weixin_56154577的博客
01-24 1880
图的广度优先遍历（BFS）是一种用于访问和处理图中节点的算法。从起始节点开始，逐层访问节点，先访问离起始节点最近的节点，然后逐层向外扩展。通过队列实现，保证按照广度顺序遍历，用于查找最短路径、连通性检测等。
图的深度优先遍历与广度优先遍历(C语言实现)
10-17
数据结构中的图结构，其中最重要的两个遍历算法——深度优先遍历与广度优先遍历
C++实现图的深度优先遍历和广度优先遍历
热门推荐
JMW1407的博客
09-24 1万+
图的深度优先遍历 图的深度优先遍历参考 图的深度优先遍历 参考 1、https://blog.csdn.net/todd911/article/details/9191481 2、https://blog.csdn.net/weixin_42109012/article/details/94199335
广度优先遍历(c实现)
qq_57437175的博客
04-11 2915
例1：城市最短路径问题 1. 题目： 已知若干个城市的地图，，求从一个初始到另一个城市的路径，要求该路径经过的城市最少 2. 算法设计： 我们可以使用广度优先遍历的思想来解决这个问题 图的广度优先搜索类似于树的层次遍历，逐层搜索正好可以尽快找到一个结点与另一个结点相对而言最直接的距离 程序实现 #include<stdio.h> #define N 8//N表示有8个结点，进行宏定义再之后的修改时比较方便 //建立一个存储图的结点信息的邻接矩阵 int a[N][N] = {{0,
数据结构-c语言-带main函数-图7.3-图的遍历-广度优先搜索-队列-邻接表-无向图。
06-24
在本文中，我们将深入探讨如何使用C语言实现无向图的广度优先搜索（BFS）遍历，其中涉及到了数据结构如邻接表、队列，并使用了CFree软件进行辅助开发。首先，让我们详细了解这些概念。 **数据结构：邻接表** 邻接表...
C++实现图的邻接表存储和广度优先遍历实例分析
12-26
本文实例讲述了C++实现图的邻接表存储和广度优先遍历方法。分享给大家供大家参考。具体如下： 示例：建立如图所示的无向图 由上图知，该图有5个顶点，分别为a,b,c,d,e,有6条边. 示例输入（按照这个格式输入）： 5 6...
图的深度、广度优先遍历（c语言）.rar
05-07
在这个压缩包中，包含了一个用C语言实现的程序，用于执行图的深度优先遍历（DFS, Depth-First Search）和广度优先遍历（BFS, Breadth-First Search）。以下是这两个遍历方法的详细解释： 1. **深度优先遍历（DFS）*...
广度优先遍历图C语言程序
04-18
这是一个可在MATLAB中调用的，用C语言编写的广度优先遍历图程序，遍历具有大量节点（大于1000）的图时速度很快。
深度优先、广度优先搜索算法C语言版
05-20
数据结构课程中的深度优先搜索算法、广度优先搜索算法的C语言程序，在Turbo C 2.0上调试通过。
广度优先搜索遍历c语言,c语言实现图的深度优先遍历和广度优先遍历
weixin_34508986的博客
05-23 956
//代码可直接运行#include #include #define maxsize 100typedef struct ArcNode {int num;struct ArcNode *next;}ArcNode;typedef struct VNode{ArcNode *firstarc;}VNode;typedef struct Graph {VNode VNodeList[maxsize]...
C语言入门——BFS图的广度优先遍历
jsnsbhzukkzns的博客
01-25 656
本博客为考试服务，研究邻接表表示法下BFS的实现。图的定义以及邻接矩阵表示法，请参见涉及到的数据结构知识点：单链表、队列、图。
C语言：广度优先遍历算法
零小唬的博客
10-09 2573
广度优先遍历算法
数据结构 广度优先遍历 c语言
Royi的学习博客
10-04 458
好的，广度优先遍历（BFS）是一种树、图的遍历算法，它从树、图的起始节点开始，逐层遍历所有节点。在每一层中，它会遍历所有节点，然后进入下一层。BFS是深度优先遍历（DFS）的一种变体，，因为BFS总是从起始节点开始搜索，而不会跳过节点，因此它会找到从起始节点到其他所有节点的最短路径。
图的广度优先搜索遍历 -- c语言
qq_43402544的博客
10-31 5024
图的广度优先搜索遍历，以我的理解是：先以一个顶点做起点，一层一层的进行输出打印。 这里引用书上的一个例子。 完整代码如下（邻接表的形式）： #include <stdio.h> #include <stdlib.h> #include <string.h> #define MVNum 100 //最大顶点数 //创建一个中断函数 void Interrupt(void)//创建一个中断函数 { while(1)//用于检测换行符，使函数脱离scanf的连续输出
图的深度和广度优先遍历（C语言）
liuchiang03的博客
06-24 6639
图的深度优先遍历和广度优先遍历算法
C语言实现深度优先遍历和广度优先遍历
11-28
以下是C语言实现深度优先遍历和广度优先遍历的代码示例： 深度优先遍历： ```c #include #define MAX 100 int visited[MAX]; // 记录节点是否被访问过 int graph[MAX][MAX]; // 存储图的邻接矩阵 int n; // 图中...
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Attract1206

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

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

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

打赏作者

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

抵扣说明：

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

余额充值