【数据结构】无向图创建邻接表以及深度遍历、广度遍历（C语言版）

最新推荐文章于 2024-05-18 23:19:00 发布
最新推荐文章于 2024-05-18 23:19:00 发布
阅读量1.7k 收藏 37
点赞数 10
分类专栏： 数据结构与算法 文章标签： 数据结构 c语言 深度优先 深度遍历 广度遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62140641/article/details/135411189
版权
数据结构——无向图创建邻接表以及深度遍历、广度遍历

一、邻接表概念

在无向图中，顶点存储在顶点表中，以一个顶点为标记，指向边链表，两者组合在一起，称为 邻接表

  1. 对无向图的每个顶点vi建立一个单链表，第i个单链表中的结点表示依附于顶点vi的边（对于有向图则是以顶点vi为尾的弧）。这个单链表就称为顶点vi的边表（对于有向图则称为出边表）
  2. 边表的头指针和顶点的数据信息采用顺序存储（称为顶点表）
  3. 邻接表中存在两种结点：顶点表结点和边表结点
  4. 顶点表结点由顶点域（data）和指向第一条邻接边的指针（firstarc）构成
  5. 边表（邻接表）结点由邻接点域（adjvex）和指向下一条邻接边的指针域（nextarc）构成

如图：

在这里插入图片描述

在这里插入图片描述

二、邻接表实现

具体样例

在这里插入图片描述

基本每一步，都有注释！！可认真看并理解！！！

（1）准备前提——结构体定义

#define MAXSIZE 100

//深度遍历标记数组 
int DfsVist[MAXSIZE]; 
//广度遍历标记数组 
int BfsVist[MAXSIZE];

//	边链表 
typedef struct EdgeLink{
	
	int Local;					//	存放该顶点对应边链表中数据 						 
	
	struct EdgeLink *next;		//	边链表节点指针  
	
}Edge,*ELINK;

//	顶点表 
typedef struct VertexLink{
	
	int Vertex;					//	存放一条边链表对应的顶点 
	ELINK FirstNode;			//	指向该顶点对应边链表的头节点 
	
}Vertex[MAXSIZE],*VLINK;

//	存放顶点和边，指向顶点表结构体数组 
typedef struct MyGraph{
	
	int Vnum;	//	存放顶点数 
	int Enum;	//	存放边数 
	
	Vertex List;	//	边链表对应的顶点表中顶点结构体 
	
}MyGraph;

（2）创建边链表

//	创建边链表
void CreateLink(MyGraph *T)
{
	int i,j;
	int v1,v2;
	ELINK p;		//	边链表指针 
	ELINK q;
	
	printf("请输入顶点数和边数(空格隔开):\n");
	
	scanf("%d%d",&(T->Vnum),&(T->Enum));
	
	
	//	初始化顶点表结构体数组 
	for(i=0;i<T->Vnum;i++)
	{
		printf("请输入第%d个顶点的信息:\n",i+1);
		
		scanf("%d",&(T->List[i].Vertex));		//	存放顶点在顶点表中 
		
		T->List[i].FirstNode = NULL; 		//	让每个顶点表第一个指向边链表的指针为NULL 
	}
	
	//	打印顶点坐标和顶点表中顶点数据 
	printf("---------------------------\n"); 
	for(i=0;i<T->Vnum;i++)
	{
		printf("顶点下标为:%d   顶点数据为: %d\n",i,T->List[i].Vertex); 	
	}
	printf("---------------------------\n");
	
	//	插入边链表数据	
	for(i=0;i<T->Enum;i++)
	{
		//	因为顶点表为顺序表，所以要按顶点顺序输入相连边 
		printf("请输入两个连接顶点下标(空格隔开):\n");
		
		scanf("%d%d",&v1,&v2);
		getchar(); 
		
		q = (ELINK)malloc(sizeof(Edge));	//	创建边链表节点，分配内存 
				
		q->Local = v2;	//	记录与该顶点连接边的顶点坐标
				
		q->next = NULL;						//	让尾巴指向NULL 
				
		if(!T->List[v1].FirstNode){	//	判断是否为这个顶点第一个指向的数据 
					
			T->List[v1].FirstNode = q;
					
		}else{
				//	这个顶点已经指向了一条边，以这条边为头节点，尾插法 
			p = T->List[v1].FirstNode;	//	临时存放头节点 
			while(p->next)	//	让节点指针遍历到尾巴上 
			{
				p = p->next;
			}
			p->next = q;	//	让新插的节点连接到之前边节点的尾巴上 
		}
			
		q = (ELINK)malloc(sizeof(Edge));	//	创建边链表节点，分配内存 
				
		q->Local = v1;	//	记录与该顶点连接边的顶点坐标
			
		q->next = NULL;						//	让尾巴指向NULL 
				
		if(!T->List[v2].FirstNode){	//	判断是否为这个顶点第一个指向的数据 
					
			T->List[v2].FirstNode = q;
					
		}else{
					//	这个顶点已经指向了一条边，以这条边为头节点，尾插法 
			p = T->List[v2].FirstNode;	//	临时存放头节点 
			while(p->next)	//	让节点指针遍历到尾巴上 
			{
				p = p->next;
			}
			p->next = q;	//	让新插的节点连接到之前边节点的尾巴上 
		}	
	} 
}

（3）打印边链表

//	打印邻接表 
void PrintLink(MyGraph *S) 
{
	MyGraph *T = S;
	ELINK Q;			//	防止边链表指针指到NULL ，用临时指针代替遍历打印 
		
	int i;
	printf("打印邻接表结果如下:\n");
	for(i=0;i<T->Vnum;i++)
	{
		Q = T->List[i].FirstNode;	//	接受每个顶点指向对应边链表的头节点指针 
		printf("%d--->",i);
		
		while(1)
		{
			if(Q == NULL)	//	指针指到尾巴 NULL
			{
				putchar('\n');
				break;
			}
			printf("------->%3d",Q->Local);
			
			Q = Q->next;	
		}
	}
	putchar('\n');
}

（4）深度优先遍历

//*****************	深度优先遍历算法—邻接表 *****************//
void DFS_Link(MyGraph *T,int n)
{	
	int i,j;
	ELINK q;	//	指向边链表节点指针 
	
	if(n<0 || n>=T->Vnum)
	{
		printf("输入有误\n");
		return;	
	}
		DfsVist[n] = 1;		//	遍历一个顶点，做下标记 1  

		printf(" %d",T->List[n].Vertex);
		
		q = T->List[n].FirstNode;	//q指向下标为i所对顶点 对应的边链表的第一个边结点	
		
		while(q!=NULL)	
		{	
			if(DfsVist[q->Local]!=1)
			{
			
				j = q->Local;
				DFS_Link(T,j);
			} 
			
			q = q->next;
		} 
} 
//	初始化深度遍历—邻接表 
void Init_DFSLINK(MyGraph *Q)
{
	int i;
	for(i=0;i<Q->Vnum;i++)
	{
		DfsVist[i] = 0;
	}
		
	for(i=0;i<Q->Vnum;i++)
	{
		if(!DfsVist[i])
		{
		 DFS_Link(Q,i);	//	此顶点没有被标记，开始递归遍历
		}
	}
	putchar('\n'); 
}

（5）广度优先搜索

//	广度遍历 
void BFS(MyGraph *S,int t)
{
	ELINK P; 			//	指向顶点所对应的边链表中 
	
	int i;
	int v;		//	用来接收边链表对应的顶点
	
	
	//	创建一个数组队列 
	int Queue[MAXSIZE];
	int front = 0;			//	队头 
	int rear = 0;			//	队尾 
		
	printf("%d ",S->List[t].Vertex);	//	输出当前遍历边链表的顶点 
	BfsVist[t] = 1;		//	将该顶点作标记
	
	rear = (rear+1)%MAXSIZE;	//	入队一个让队尾指向后移一位
	Queue[rear] = t;	 		//	将该顶点入队 

	while(front != rear)	//	若front == rear，表明这个顶点在边链表上连接的顶点已经遍历完毕 
	{
		front = (front+1)%MAXSIZE;		//	出队 
	
		v = Queue[front];			//	得到此时遍历到顶点坐标 
		
		P = S->List[v].FirstNode;	//	遍历当前顶点指向边链表中连接的其他顶点
									//	也就是换个顶点的边链表继续遍历查找剩余顶点 
		while(P!=NULL)
		{
			
			if(BfsVist[P->Local] == 0)
			{			
				printf("%d ",P->Local+1);	//	输出连接边顶点 
				
				BfsVist[P->Local] = 1;		//	作标记,表示这个顶点已经搜索过 
				
				rear = (rear+1)%MAXSIZE;		//	将该下标入队 
				
				Queue[rear] = P->Local;	//	把遍历到新的边链表对应的顶点坐标入队 
			}
			
			P = P->next;	//	遍历这个顶点的边链表 
		}	
	} 
} 

//	BFS广度遍历初始化
void Init_BFS(MyGraph *S)
{
	int i;
	
	for(i=0;i<S->Vnum;i++)
	{
		BfsVist[i] = 0;	//	初始化标记符 
	}
	
	for(i=0;i<S->Vnum;i++)
	{
		if(BfsVist[i]==0)
			BFS(S,i);
	}	
}

（6）全部代码

#include<stdio.h>
#include<stdlib.h>

#define MAXSIZE 100

//深度遍历标记数组 
int DfsVist[MAXSIZE]; 
//广度遍历标记数组 
int BfsVist[MAXSIZE];

//	边链表 
typedef struct EdgeLink{
	
	int Local;					//	存放该顶点对应边链表中数据 						 
	
	struct EdgeLink *next;		//	边链表节点指针  
	
}Edge,*ELINK;

//	顶点表 
typedef struct VertexLink{
	
	int Vertex;					//	存放一条边链表对应的顶点 
	ELINK FirstNode;			//	指向该顶点对应边链表的头节点 
	
}Vertex[MAXSIZE],*VLINK;

//	存放顶点和边，指向顶点表结构体数组 
typedef struct MyGraph{
	
	int Vnum;	//	存放顶点数 
	int Enum;	//	存放边数 
	
	Vertex List;	//	边链表对应的顶点表中顶点结构体 
	
}MyGraph;

//	创建边链表
void CreateLink(MyGraph *T)
{
	int i,j;
	int v1,v2;
	ELINK p;		//	边链表指针 
	ELINK q;
	
	printf("请输入顶点数和边数(空格隔开):\n");
	
	scanf("%d%d",&(T->Vnum),&(T->Enum));
	
	
	//	初始化顶点表结构体数组 
	for(i=0;i<T->Vnum;i++)
	{
		printf("请输入第%d个顶点的信息:\n",i+1);
		
		scanf("%d",&(T->List[i].Vertex));		//	存放顶点在顶点表中 
		
		T->List[i].FirstNode = NULL; 		//	让每个顶点表第一个指向边链表的指针为NULL 
	}
	
	//	打印顶点坐标和顶点表中顶点数据 
	printf("---------------------------\n"); 
	for(i=0;i<T->Vnum;i++)
	{
		printf("顶点下标为:%d   顶点数据为: %d\n",i,T->List[i].Vertex); 	
	}
	printf("---------------------------\n");
	
	//	插入边链表数据	
	for(i=0;i<T->Enum;i++)
	{
		//	因为顶点表为顺序表，所以要按顶点顺序输入相连边 
		printf("请输入两个连接顶点下标(空格隔开):\n");
		
		scanf("%d%d",&v1,&v2);
		getchar(); 
		
		q = (ELINK)malloc(sizeof(Edge));	//	创建边链表节点，分配内存 
				
		q->Local = v2;	//	记录与该顶点连接边的顶点坐标
				
		q->next = NULL;						//	让尾巴指向NULL 
				
		if(!T->List[v1].FirstNode){	//	判断是否为这个顶点第一个指向的数据 
					
			T->List[v1].FirstNode = q;
					
		}else{
				//	这个顶点已经指向了一条边，以这条边为头节点，尾插法 
			p = T->List[v1].FirstNode;	//	临时存放头节点 
			while(p->next)	//	让节点指针遍历到尾巴上 
			{
				p = p->next;
			}
			p->next = q;	//	让新插的节点连接到之前边节点的尾巴上 
		}
			
		q = (ELINK)malloc(sizeof(Edge));	//	创建边链表节点，分配内存 
				
		q->Local = v1;	//	记录与该顶点连接边的顶点坐标
			
		q->next = NULL;						//	让尾巴指向NULL 
				
		if(!T->List[v2].FirstNode){	//	判断是否为这个顶点第一个指向的数据 
					
			T->List[v2].FirstNode = q;
					
		}else{
					//	这个顶点已经指向了一条边，以这条边为头节点，尾插法 
			p = T->List[v2].FirstNode;	//	临时存放头节点 
			while(p->next)	//	让节点指针遍历到尾巴上 
			{
				p = p->next;
			}
			p->next = q;	//	让新插的节点连接到之前边节点的尾巴上 
		}	
	} 
}

//	打印邻接表 
void PrintLink(MyGraph *S) 
{
	MyGraph *T = S;
	ELINK Q;			//	防止边链表指针指到NULL ，用临时指针代替遍历打印 
		
	int i;
	printf("打印邻接表结果如下:\n");
	for(i=0;i<T->Vnum;i++)
	{
		Q = T->List[i].FirstNode;	//	接受每个顶点指向对应边链表的头节点指针 
		printf("%d--->",i);
		
		while(1)
		{
			if(Q == NULL)
			{
				putchar('\n');
				break;
			}
			printf("------->%3d",Q->Local);
			
			Q = Q->next;	//！！BUG 
		}
	}
	putchar('\n');
}

//*****************	深度优先遍历算法—邻接表 *****************//
void DFS_Link(MyGraph *T,int n)
{	
	int i,j;
	ELINK q;	//	指向边链表节点指针 
	
	if(n<0 || n>=T->Vnum)
	{
		printf("输入有误\n");
		return;	
	}
		DfsVist[n] = 1;		//	遍历一个顶点，做下标记 1  

		printf(" %d",T->List[n].Vertex);
		
		q = T->List[n].FirstNode;	//q指向下标为i所对顶点 对应的边链表的第一个边结点	
		
		while(q!=NULL)	
		{	
			if(DfsVist[q->Local]!=1)
			{
			
				j = q->Local;
				DFS_Link(T,j);
			} 
			
			q = q->next;
		}	 
} 

//	初始化深度遍历—邻接表 
void Init_DFSLINK(MyGraph *Q)
{
	int i;
	for(i=0;i<Q->Vnum;i++)
	{
		DfsVist[i] = 0;
	}
		
	for(i=0;i<Q->Vnum;i++)
	{
		if(!DfsVist[i])
		{
		 DFS_Link(Q,i);	//	此顶点没有被标记，开始递归遍历
		}
	}
	putchar('\n'); 	
}

//	广度遍历 
void BFS(MyGraph *S,int t)
{
	ELINK P; 			//	指向顶点所对应的边链表中 
	
	int i;
	int v;		//	用来接收边链表对应的顶点
	
	//	为了不和广度搜素—邻接矩阵冲突
	//	创建一个数组队列 
	int Queue[MAXSIZE];
	int front = 0;			//	队头 
	int rear = 0;			//	队尾 
		
	printf("%d ",S->List[t].Vertex);	//	输出当前遍历边链表的顶点 
	BfsVist[t] = 1;		//	将该顶点作标记
	
	rear = (rear+1)%MAXSIZE;	//	入队一个让队尾指向后移一位
	Queue[rear] = t;	 		//	将该顶点入队 

	while(front != rear)	//	若front == rear，表明这个顶点在边链表上连接的顶点已经遍历完毕 
	{
		front = (front+1)%MAXSIZE;		//	出队 
	
		v = Queue[front];			//	得到此时遍历到顶点坐标 
		
		P = S->List[v].FirstNode;	//	遍历当前顶点指向边链表中连接的其他顶点
									//	也就是换个顶点的边链表继续遍历查找剩余顶点 
		while(P!=NULL)
		{
			
			if(BfsVist[P->Local] == 0)
			{			
				printf("%d ",P->Local+1);	//	输出连接边顶点 
				
				BfsVist[P->Local] = 1;		//	作标记,表示这个顶点已经搜索过 
				
				rear = (rear+1)%MAXSIZE;		//	将该下标入队 
				
				Queue[rear] = P->Local;	//	把遍历到新的边链表对应的顶点坐标入队 
			}
			
			P = P->next;	//	遍历这个顶点的边链表 
		}	
	} 
} 

//	BFS广度遍历初始化
void Init_BFS(MyGraph *S)
{
	int i;
	
	for(i=0;i<S->Vnum;i++)
	{
		BfsVist[i] = 0;	//	初始化标记符 
	}
	
	for(i=0;i<S->Vnum;i++)
	{
		if(BfsVist[i]==0)
			BFS(S,i);
	}
} 

int main()
{
	MyGraph *S;
	S = (MyGraph *)malloc(sizeof(MyGraph));
	
	//	创建边链表 
	CreateLink(S);
	
	//	打印边链表 
	PrintLink(S);
	
	//	深度遍历
	Init_DFSLINK(S); 
	
	//	广度遍历 
	Init_BFS(S);
	 
	return 0;	
}

运行结果：
在这里插入图片描述

咖喱年糕
关注
  • 10
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
邻接表实现图的深度遍历和广度遍历
binge_kong的博客
05-02 5211
"ALG.h"头文件 定义图及其各种操作 #pragma once #include <iostream> #include <string> using namespace std; const int MVNum = 100; //边结点定义 typedef struct ArcNode { int adjvex; //该边所指向的顶点在表头结点表数组...
邻接表深度遍历和广度遍历.h
09-11
邻接表深度遍历和广度遍历 邻接表深度遍历和广度遍历 邻接表深度遍历和广度遍历 邻接表深度遍历和广度遍历
无向图的表示：邻接矩阵和邻接表
x_i_y_u_e的专栏
06-14 2万+
这里将一个无向图用邻接表和邻接矩阵表示。 输入：顶底个数n，图中的各个边（用两个顶点表示）。 输出：这个无线图的邻接矩阵和邻接表，其中邻接表中的链接按元素大小升序排列。 先给出一个例子说明。假设有无向图如下，则其邻接矩阵和邻接表如提示框中所示（其实就是下面程序的输出）。 下面是程序的代码： #include #include //图的表示，输入节点个数和边，构造图的邻接矩阵
数据结构-邻接表及深度优先遍历及广度优先遍历
最新发布
2303_81579306的博客
05-18 215
【代码】数据结构-邻接表及深度优先遍历。
图的邻接表存储及遍历
11-30 1377
例如，如果图中没有从'A'到'B'的边，但在'B'到'A'之间有一条边，那么在邻接表中，'A'的邻居列表中不会包含'B'，但在'B'的邻居列表中会包含'A'。它从图中的一个顶点开始，然后选取所有从起始顶点出发可以达到的顶点中距离最短的顶点。它从任意一个顶点开始，然后在每一步中选取当前剩余的顶点中与已选取的顶点之间的距离最小的顶点加入到已选取的顶点集合中。直到所有的顶点都被选取为止。print(dfs(graph, 'A')) # 输出: {'A', 'B', 'C', 'D', 'E', 'F'}
无向图的邻接表
weixin_52634719的博客
12-29 3158
头结点里放当前顶点的值，以及它第一条弧的指针，表结点放邻接点的序号adjvex和指向下一边的指针 网的话，有权值，增加一个成员 无向图的邻接表，位置可互换，不唯一：边的顺序可以变 ...
C++构造无向图，邻接表，深度优先遍历，广度优先遍历
qq_44757691的博客
12-15 2566
将此边结点分别插入到vi和vj,对应的两个边链表的头部。使每个表头结点的指针域初始化为NULL。确定两个顶点的序号i和j,建立边结点。依次输入每条边依附的两个顶点。依次输入点的信息存入顶点表中。(1)输入总顶点数和总边数。
头歌数据结构图的邻接表存储及遍历操作
05-26
头歌数据结构图的邻接表存储及遍历操作 第1关图的邻接表存储及求邻接点操作 第2关图的深度遍历 第3关图的广度遍历 稳过
tuDeBianLi.rar_图C_图的 邻接表 遍历_无向图_邻接表_邻接表 广度 遍历
09-24
本篇将深入探讨图的邻接表存储结构以及如何对无向图进行深度优先遍历（DFS）和广度优先遍历（BFS）。 首先，让我们理解什么是邻接表。邻接表是图的一种高效存储方式，特别适合于稀疏图（边的数量远小于节点数量的...
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
在压缩包文件"数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历_1602077415"中，包含了关于这些主题的详细资料，可能包括理论解释、代码示例和练习题，帮助读者深入理解和掌握图的存储...
邻接表或者邻接矩阵为存储结构实现连通无向图的深度优先和广度优先遍历
12-06
在这个程序设计任务中，我们需要实现的是连通无向图的深度优先遍历（DFS）和广度优先遍历（BFS），这两种遍历方法是图算法的基础。无向图指的是图中的边没有方向，即任意两个节点之间可以双向连接。 1. **邻接表和...
大话数据结构---（六）图的深度优先遍历和广度优先遍历
松落
03-30 1万+
我们已经掌握了如何存储图中的信息，即邻接矩阵，邻接表，十字链表等。那么我们该如何利用这些存储结构中的数据呢，或者说我该如何找到我想要的数据呢，这里我们就得学会如何遍历图结构，而接下来会和大家介绍两种常用的遍历方法，深度优先遍历和广度优先遍历。
采用邻接表表示法创建无向图
qq_47142993的博客
08-08 1万+
//采用邻接表表示法创建无向图 #include <iostream> using namespace std; #define MVNum 100 //最大顶点数 #define OK 1 typedef char VerTexType; //-==顶点信息 typedef int OtherInfo; //和边相关的信息 //- - - - -图的邻接表存储表示- - - - - typedef struct A
【数据结构实验四】- 图的存储和遍历 - （无向图、有向图，深度优先、广度优先遍历）
m0_46233342的博客
03-04 8892
文章目录一、实验题目：二、实验目的：三、实验内容：1.建立无向图的邻接矩阵存储结构，进行深度优先遍历和广度优先遍历。程序代码：2.建立有向图的邻接表存储结构，进行深度优先遍历和广度优先遍历。程序代码：四、实验心得体会 实验四 一、实验题目： 图的存储和遍历 二、实验目的： ⑴ 掌握图的逻辑结构； ⑵ 掌握图的邻接矩阵存储结构和图的邻接表存储结构； ⑶ 验证图的邻接矩阵存储和邻接表的存储以及深度优先遍历和广度优先遍历操作的实现。 三、实验内容： （1）建立无向图的邻接矩阵存储； （2）对建立的无向图，进行深
图的广度优先遍历(邻接表)
t_wu的博客
04-13 2万+
1.广度优先遍历        图的广度优先遍历类似于数的层序遍历，它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域。以上便是广度优先遍历的一次过程（没循环）for 循环存放顶点的数组        如果当前顶点值未被访问过                访问它并且将它对应的判断数组变为true                将它入队                        w...
无向图的邻接表创建
weixin_30649641的博客
04-15 299
大话数据结构第一版第二次印刷中P231-P232中的无向图的邻接表创建，解释有一点小问题，但是不影响无向图邻接表的创建。 书中无向图如下： 问题如下： 1、如果data信息是V0，V1，V2，V3，需要typedef char VertexType[3];我为了方便，将V0，V1，V2，V3分别改为ABCD。 2、根据图7-4-6，V0的firstedge指向V1，V1的first...
无向图&有向图的邻接表法建立
Koisky的博客
10-29 2704
无向图的邻接表法建立 要求建立一个无向图，采用邻接表做为存储结构。 例如： 输入信息为：第一行给出图的顶点数n和边数e。第二行给出n个字符，表示n个顶点的数据元素的值。后面是e行，给出每一条边的两个顶点编号。 7 9 ABCDEFG 0 1 0 2 0 6 1 3 1 4 2 5 2 6 3 4 3 6 输出每个顶点的值以及各顶点的邻接点。 ...
6-5 图的广度遍历-邻接表实现 (10分)_数据结构实验6_羊卓的杨
qq_45800977的博客
12-17 739
6-5 图的广度遍历-邻接表实现 (10分) 函数接口定义： void BFS(ALGraph *G,int i); 其中ALGraph是邻接表存储的图，定义如下： #define MAX_VERTEX_NUM 10 /定义最大顶点数/ typedef int Vertex; typedef struct ArcNode{ /表结点/ int adjvex; /邻接点域/ struct ArcNode *nextarc; /指向下一个表结点/ }A
图---邻接表(建立，深度遍历，广度遍历)
热门推荐
无幻
07-28 4万+
图的邻接表表示法类似于树的孩子链表表示法。对于图G中的每个顶点vi，该方法把所有邻接于vi的顶点vj链成一个带头结点的单链表，这个单链表就称为顶点vi的邻接表(Adjacency List)。以下代码测试过，为图的邻接表表示方式。/*******************************************************************
邻接表储存无向图的广度优先遍历C语言
11-08
邻接表是一种常见的图的存储结构，它由一个一维数组和若干个链表组成。其中，数组中的每个元素表示一个顶点，每个顶点对应的链表中存储了与该顶点相邻的所有顶点。广度优先遍历是一种图的遍历算法，它从图的某个顶点开始，依次访问该顶点的所有邻接点，然后再依次访问这些邻接点的邻接点，直到遍历完整个图。 下面是使用邻接表储存无向图的广度优先遍历的C语言代码： ```c #include <stdio.h> #include <stdlib.h> #define MAX_VERTEX_NUM 100 // 最大顶点数 // 邻接表中的边结构体 typedef struct EdgeNode { int adjvex; // 邻接点在数组中的位置下标 struct EdgeNode *next; // 指向下一个邻接点的指针 } EdgeNode; // 邻接表中的顶点结构体 typedef struct VertexNode { int vertex; // 顶点的值 EdgeNode *firstedge; // 指向第一个邻接点的指针 } VertexNode; // 邻接表结构体 typedef struct { VertexNode adjlist[MAX_VERTEX_NUM]; // 顶点数组 int vertex_num, edge_num; // 顶点数和边数 } AdjList; // 初始化邻接表 void InitAdjList(AdjList *a, int n) { a->vertex_num = n; a->edge_num = 0; for (int i = 0; i < n; i++) { a->adjlist[i].vertex = i; a->adjlist[i].firstedge = NULL; } } // 添加边 void AddEdge(AdjList *a, int u, int v) { EdgeNode *e = (EdgeNode *)malloc(sizeof(EdgeNode)); e->adjvex = v; e->next = a->adjlist[u].firstedge; a->adjlist[u].firstedge = e; a->edge_num++; } // 广度优先遍历 void BFS(AdjList *a, int v) { int visited[MAX_VERTEX_NUM] = {0}; // 标记数组，用于记录每个顶点是否被访问过 int queue[MAX_VERTEX_NUM], front = 0, rear = 0; // 队列，用于存储待访问的顶点 EdgeNode *e; printf("%d ", v); visited[v] = 1; queue[rear++] = v; while (front != rear) { int u = queue[front++]; for (e = a->adjlist[u].firstedge; e != NULL; e = e->next) { int w = e->adjvex; if (!visited[w]) { printf("%d ", w); visited[w] = 1; queue[rear++] = w; } } } } // 主函数 int main() { int n, m, u, v; AdjList a; printf("请输入顶点数和边数："); scanf("%d%d", &n, &m); InitAdjList(&a, n); printf("请输入每条边的两个端点：\n"); for (int i = 0; i < m; i++) { scanf("%d%d", &u, &v); AddEdge(&a, u, v); AddEdge(&a, v, u); } printf("广度优先遍历结果为："); BFS(&a, 0); printf("\n"); return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

咖喱年糕

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

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

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

打赏作者

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

抵扣说明：

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

余额充值