【数据结构】C语言实现图的相关操作

最新推荐文章于 2024-02-26 13:48:34 发布
最新推荐文章于 2024-02-26 13:48:34 发布
阅读量1.6k 收藏 26
点赞数 43
分类专栏： 数据结构（C语言） 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62503332/article/details/136269998
版权

图

图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G 表示一个图，V 是图 G 中顶点的集合，E 是图 G 中边的集合。

术语

无向图：每条边都是无方向的图

有向图：每条边都是有方向的图
在这里插入图片描述

完全图：任意两个点都有一条边相连的图

边：无向图中的边

弧：有向图中的边

稀疏图：有很少边或弧的图

稠密图：有较多边或弧的图

网：边/弧带权的图（带权的意思就是边/弧上有数值）

邻接：有边/弧相连的两个顶点间的关系称为邻接

顶点的度：与该顶点相连的边的数目

在有向图中，顶点的度等于该顶点的入度和出度之和

顶点的入度是以该顶点为终点的弧的条数

顶点的出度是以该顶点为起点的弧的条数

路径：连续的边所构成的顶点序列

路径长度：路径上边/弧的数目

回路（环）：第一个顶点和最后一个顶点相同的路径

简单路径：除路径起点和终点可以相同外，其余顶点均不相同的路径

简单回路（环）：除路径起点和终点相同外，其余顶点均不相同的路径

连通图：在无向图中，从任意一个顶点出发，可以到达其余任意顶点

强连通图：在有向图中，从任意一个顶点出发，可以到达其余任意顶点

权：图中边或弧所具有的相关树称为权，表明从一个顶点到另一个顶点的距离或耗费

网：带权的图称为网

存储结构

  • 顺序存储结构

邻接矩阵（数组表示法）

  • 链式存储结构

邻接表（链式表示法）

邻接矩阵

设图的顶点数量为 n，邻接矩阵使用一个 n * n 大小的矩阵（二维数组）来表示图，每一行（列）代表一个顶点，用1或0表示两个顶点之间是否存在边

建立一个顶点表（记录各个顶点信息）和一个邻接矩阵（表示各个顶点之间关系）

无向图：
在这里插入图片描述

有向图：
在这里插入图片描述

有向图的邻接矩阵中，行号表示弧的起点，列号表示弧的终点

如果想要表示网，则将邻接矩阵中的0换成无穷大即可

表示
#define MAX_INT 2147483647
#define MAX_V_NUM 100

typedef struct AMGraph
{
	char vexs[MAX_V_NUM];
	int arcs[MAX_V_NUM][MAX_V_NUM];
	int vex_num;
	int arc_num;
}AMGraph;

MAX_INT：表示极大值，即无穷大，用在网中

MAX_V_NUM：表示最大顶点树

AMGraph：Adjacency Matrix Graph 邻接矩阵图

char vexs[MAX_V_NUM]：顶点表

int arcs[MAX_V_NUM][MAX_V_NUM]：邻接矩阵，表示顶点间的关系

int vex_num：图的顶点数

int arc_num：图的边数

创建无向图

思路：

  1. 输入图的顶点数和边数
  2. 将点的信息存入顶点表中
  3. 初始化邻接矩阵
  4. 构造邻接矩阵，将边的信息存入矩阵中
void create_UDG(AMGraph* G)
{
	//输入图的顶点数和边数
	printf("Enter vex num:");
	scanf("%d", &G->vex_num);
	printf("Enter arc num:");
	scanf("%d", &G->arc_num);
	//将点的信息存入顶点表中（所谓的点的信息，其实就是点的名字）
	int i = 0;
	int j = 0;
	for (i = 0; i < G->vex_num; i++)
	{
		printf("Enter information for the %d-th vertex:", i + 1);
		scanf(" %c", &G->vexs[i]);
	}

	//初始化邻接矩阵
	for (i = 0; i < G->vex_num; i++)
	{
		for (j = 0; j < G->vex_num; j++)
		{
			G->arcs[i][j] = 0;	//网：MAX_INT，图：0
		}
	}

	//构造邻接矩阵
	for (i = 0; i < G->arc_num; i++)
	{
		char v1 = 0;
		char v2 = 0;
		//int w = 0;
		printf("Input two connected vertices：");
		scanf(" %c %c", &v1, &v2);

		//printf("Enter the starting point of the edge:");
		//scanf(" %c", &v1);
		//printf("Enter the endpoint of the edge:");
		//scanf(" %c", &v2);
		//printf("Input the weight of the edge:");
		//scanf("%d", &w);

		int i = locate_vex(G, v1);
		int j = locate_vex(G, v2);
		//G->arcs[i][j] = w;
		G->arcs[i][j] = 1;
		G->arcs[j][i] = G->arcs[i][j];
	}
}

int locate_vex(AMGraph* G, char v)
{
	int i = 0;
	for (i = 0; i < G->vexs; i++)
	{
		if (v == G->vexs[i])
		{
			return i;
		}
	}
	return -1;
}

以上代码，进行适当的修改，可以用来创建有向图、无向网、有向网

邻接表

在这里插入图片描述

邻接表（adjacency list）使用 n 个链表来表示图，链表结点表示顶点。链表中存储了该顶点的所有邻接顶点（与该顶点相连的顶点）
在这里插入图片描述

顶点表中的结点分为数据域和链域，数据域存储顶点信息，链域指向链表中的第一个结点

链表中的结点分为邻接点域、链域和数据域，邻接点域表示该顶点，存储顶点在顶点表中的位置，链域指向下一个相连的顶点，数据域存储与边有关的信息（权值）
在这里插入图片描述

在有向图中，链接的都是弧指向的顶点（如果反过来，那就是逆邻接表）

表示
#define MAX_INT 2147483647
#define MAX_V_NUM 100

//ArcNode 表示链表中的结点
typedef struct ArcNode
{
	int adjvex;				//该顶点在顶点表中的位置
	struct ArcNode* nextarc;//指向下一个相连的顶点
	int info;				//存储与边有关的信息（权值）
}ArcNode;

//VNode 表示顶点表中的结点
typedef struct VNode
{
	char data;				//顶点信息
	ArcNode* firstarc;		//指向与该顶点第一个相连的顶点
}VNode, AdjList[MAX_V_NUM];	//AdjList 表示顶点表

//ALGraph 用邻接表表示的图
typedef struct ALGraph
{
	AdjList vertices;	//顶点表 verticse是vertex的复数
	//相当于AdjList vertices[MAX_V_NUM]
	int vex_num;		//图的顶点数
	int arc_num;		//图的边数
}ALGraph;
创建无向图

思路：

  1. 输入顶点数和边数
  2. 建立顶点表（输入顶点信息，指针域置NULL）
  3. 创建邻接表
void create_UDG(ALGraph* G)
{
	//输入图的顶点数和边数
	printf("Enter vex num:");
	scanf("%d", &G->vex_num);
	printf("Enter arc num:");
	scanf("%d", &G->arc_num);

	//将点的信息存入顶点表中
	int i = 0;
	int j = 0;
	for (i = 0; i < G->vex_num; i++)
	{
		printf("Enter information for the %d-th vertex:", i + 1);
		scanf(" %c", &G->vertices[i].data);
		G->vertices[i].firstarc = NULL;
	}
	//创建邻接表
	for (i = 0; i < G->arc_num; i++)
	{
		char v1 = 0;
		char v2 = 0;
		printf("Input two connected vertices:");
		scanf(" %c %c", &v1, &v2);
		int i = locate_vex(G, v1);
		int j = locate_vex(G, v2);

		ArcNode* p1 = (ArcNode*)malloc(sizeof(ArcNode));
		if (p1 == NULL)
		{
			exit(0);
		}
		ArcNode* p2 = (ArcNode*)malloc(sizeof(ArcNode));
		if (p2 == NULL)
		{
			exit(0);
		}
		//p1结点是和顶点v1相连的结点，所以p1结点存的是顶点v2的信息
		p1->adjvex = j;
		//头插法建立链表，因此，最后的输出的次序和输入的次序是相反的（DFS、BFS）
		p1->nextarc = G->vertices[i].firstarc;
		G->vertices[i].firstarc = p1;

		p2->adjvex = i;
		p2->nextarc = G->vertices[j].firstarc;
		G->vertices[j].firstarc = p2;
	}
}

int locate_vex(ALGraph* G, char v)
{
	int i = 0;
	for (i = 0; i < G->vex_num; i++)
	{
		if (v == G->vertices[i].data)
		{
			return i;
		}
	}
	return -1;
}

优缺点

邻接矩阵

  • 优点

方便查找”邻接点“

方便计算顶点的”度“

  • 缺点

不便于增加和删除顶点

浪费空间，如果是稀疏图，会有大量的空间浪费

邻接表

  • 优点

方便查找”邻接点“

节约空间

  • 缺点

不便于检查任意一对顶点间是否存在边

邻接矩阵多用于稠密图，邻接表多用于稀疏图

图的遍历

遍历：从已给出的连通图中的某一顶点出发，沿着一些边访遍图中的所有顶点，且每个顶点仅被访问一次

以下代码都是假设所要搜索的图是无向图

深度优先搜索

深度优先搜索（Depth First Search）（DFS）

思路：

构造一个辅助数组 visited[i]，用来标记每个被访问过的顶点

在访问图中某一起始顶点 v 后，由 v 出发，访问它的任一邻接顶点 w1

再从 w1 出发，访问与 w1 邻接但未被访问过的顶点 w2

再从 w2 出发，进行类似的访问

如此反复，直至到达所有的邻接顶点都被访问过的顶点 u 为止

接着，回退一步，退到前一次访问的顶点，看是否还有其他未被访问的邻接顶点

如果有，访问该顶点，再从该顶点出发，进行访问

如果没有，继续回退，重复之前步骤，直到图中所有的顶点都被访问过

例如：
在这里插入图片描述

对于该图的深度优先搜索，有如下访问次序：

v1、v2、v4、v8、v5、v3、v6、v7

v1、v3、v6、v7、v2、v4、v8、v5

…

基于邻接矩阵

void DFS(AMGraph* G, char v, int visited[MAX_V_NUM])
{
	printf("%c ", v);
	int i = locate_vex(G, v);
	visited[i] = 1;

	int j = 0;
	for (j = 0; j < G->vex_num; j++)
	{
		if (G->arcs[i][j] != 0 && visited[j] != 1)
		{
			char next_v = G->vexs[j];
			DFS(G, next_v, visited);
		}
	}
}

基于邻接表

void DFS(ALGraph* G, char v, int visited[MAX_V_NUM])
{
	int i = locate_vex(G, v);
	visited[i] = 1;
	printf("%c ", v);

	ArcNode* p = G->vertices[i].firstarc;
	while (p != NULL)
	{
		char next_v = G->vertices[p->adjvex].data;
		i = locate_vex(G, next_v);
		if (visited[i] == 0)
		{
			DFS(G, next_v, visited);
		}
		p = p->nextarc;
	}
}

广度优先搜索

广度优先搜索（Breadth First Search）（BFS）

思路：

从图的某一顶点出发，首先依次访问该顶点的所有邻接点，再按访问这些邻接点的顺序，依次访问与它们相邻接的且未被访问过的顶点，重复此过程，直到所有顶点被访问为止

例如：
在这里插入图片描述

访问次序：

v1、v2、v3、v4、v5、v6、v7、v8

基于邻接矩阵

void BFS(AMGraph* G, char v, int visited[MAX_V_NUM])
{
	printf("%c ", v);
	int i = locate_vex(G, v);
	visited[i] = 1;
	Queue Q;
	init(&Q);
	in(&Q, v);
	while (isEmpty(&Q) != 1)	//队列不为空时，循环继续
	{
		char u = out(&Q);		//队头出队
		i = locate_vex(G, u);	
		int j = 0;
		for (j = 0; j < G->vex_num; j++)	//找出队顶点的邻接点
		{
			if (G->arcs[i][j] != 0 && visited[j] != 1)
			{
				//输出顶点信息，然后该顶点入队
				char next_v = G->vexs[j];	
				printf("%c ", next_v);
				visited[j] = 1;
				in(&Q, next_v);
			}
		}
	}
}

基于邻接表

void BFS(ALGraph* G, char v, int visited[MAX_V_NUM])
{
	Queue Q;
	init(&Q);
	printf("%c ", v);
	int i = locate_vex(G, v);
	visited[i] = 1;
	in(&Q, v);

	while (isEmpty(&Q) != 1)
	{
		char u = out(&Q);
		i = locate_vex(G, u);

		ArcNode* p = G->vertices[i].firstarc;
		while (p != NULL)
		{
			if (visited[p->adjvex] == 0)
			{
				char next_v = G->vertices[p->adjvex].data;
				printf("%c ", next_v);
				visited[p->adjvex] = 1;
				in(&Q, next_v);
			}
			p = p->nextarc;
		}
	}
}
长白秋沙
关注
  • 43
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现数据结构和双向链表操作
01-21
数据结构 双向链表的实现 双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。 双向链表结点的类型描述： //双向链表的类型描述 typedef ...
图的创建-有向图
hhhhhiihhh的博客
01-01 1249
有向图的创建-邻接表
【数据结构-图】C语言实现邻接矩阵表示无向图（网）和有向图（网）及深度遍历
weixin_43716338的博客
02-21 7349
邻接矩阵表示图及其深度优先遍历图的邻接矩阵储存表示定位顶点的位置邻接矩阵表示法创建无向网获取邻接点深度优先遍历连通图算法邻接矩阵表示图的深度优先遍历测试代码整合结果 图的邻接矩阵储存表示 #define MaxInt 32767 #define MVNum 100 typedef int Status; typedef char VerTexType; //顶点类型 typedef int ArcType; //边的权值类型 int visited[MVNum]; //图的邻接矩阵
C语言 图的建立（邻接矩阵与邻接表）
m0_73070900的博客
05-25 3980
5Cinfty。
【数据结构-图】C语言实现邻接表表示无向图（网）和有向图（网）及深度遍历
weixin_43716338的博客
02-23 3934
C语言实现邻接表表示法创建图及深度遍历邻接表表示法创建图创建无向图存储表示定位顶点位置创建无向图邻接表无向图深度优先遍历深度优先遍历基本操作测试代码整合深度遍历结果创建无向网代码表示深度遍历结果创建有向图代码表示深度遍历结果创建有向网代码表示深度遍历结果 邻接表表示法创建图 创建无向图 创建这样一个无向图。 用邻接表表示，则是如下： 存储表示 //存储表示 int visited[MVNum]; typedef int Status; typedef char VerTexType; typede
C语言 有向图的创建、求度、遍历（用领接矩阵存储法）
weixin_44119517的博客
12-01 1731
#include<stdio.h> #include<malloc.h> #include<string.h> #define MAXVEX 20 //最大顶点个数 #define INFINTY -1 //表示无穷 //∞无穷 typedef struct{ int arcs[MAXVEX][MAXVEX];//边(弧)信息 char vex...
数据结构中单链表的操作用C语言实现
09-23
适用于大学生计算机学科学习数据结构
C语言实现数据结构迷宫实验
01-01
本文实例为大家分享了C语言实现简单的数据结构迷宫实验，供大家参考，具体内容如下 分析：迷宫实验主要有两部分操作，其一是对迷宫的生成，其二是寻路使用栈的操作。 步骤： 一、.h文件 1、首先是迷宫的生成，可以...
c语言 数据结构实现之字符串
08-30
主要介绍了c语言 数据结构实现之字符串的相关资料,需要的朋友可以参考下
基本数据结构C语言实现
04-12
用C语言实现的部分数据结构的基本操作 例如迷宫游戏 哈弗曼树等等
图的创建（有向图，无向图，有向网，无向网）及输出
06-25
这个是我学数据结构是老师留的上机作业，主要就是图的创建与输出，分四种分别为有向图，无向图，有向网，无向网，通过选择类型来选择图的种类
数据结构-----图(graph)的储存和创建
m0_73633088的博客
10-20 1681
邻接矩阵是图的矩阵表示，借助它可以方便地存储图的结构，用线性代数的方法研究图的问题。 如果一个图有 n 个顶点，其邻接矩阵 W 为 ntimes n 的矩阵，矩阵元素 w_ {ij} 表示边 (i,j) 的权重。 如果两个顶点之间没有边连接，则在邻接矩阵中对应的元素为0。
C-图算法
最新发布
weixin_39512905的博客
02-26 824
首先，我们定义一个常量来表示图中的节点数量。然后，我们定义一个二维数组来作为邻接矩阵，如果节点i和节点j之间存在一条边，那么矩阵的第i行第j列的值就是1，否则就是0。，使用邻接表（Adjacency List）来表示图通常是一个更加高效的选择，因为邻接表仅存储实际存在的边，从而可以节省大量的内存空间。在这个函数中，你可以根据你的需要来填充矩阵，例如通过随机生成边或根据某种特定的规则来添加边。然后，我们使用嵌套循环来遍历矩阵中的每个元素，如果元素的值是1，那么我们就打印出一条从节点i到节点j的边。
数据结构（C语言）图的创建和度数统计（基础）
小心信科理化声
05-27 1652
图 图结构：是研究数据元素之间的多对多的关系。在这种结构中，任意两个元素之间可能存在关系。即结点之间的关系可以是任意的，图中任意元素之间都可能相关。 图的应用极为广泛，已渗入到诸如语言学、逻辑学、物理、化学、电讯、计算机科学以及数学的其它分支。 一个图(G)定义为一个偶对(V,E)，记为G=(V,E) 。其中：V是顶点(Vertex)的非空有限集合，记为V(G)；E是无序集(V,V)的一个子集，记为E(G) ，其元素是图的弧(Arc)。 图的分类 有向图(Digraph)：若图G的关系集合E(G)中，顶点偶
c语言数据结构-图的概念
来自计科大一萌新的编程记录本
02-07 1035
c语言数据结构-图的概念
数据结构之图（C语言）
sskdspdl的博客
10-22 1627
用C语言实现图的创建与遍历
6.图——数据结构（严蔚敏 C语言版）
一个人的博客
08-06 1476
6.图 6.1定义和术语 无向图: 每条边都是无方向的 有向图: 每条边都是有方向的 完全图: 任意两个点都有一条边相连。 无向完全图：n个顶点，n（n-1)/2条边 有向完全图：n个顶点，n(n-1)条边 网: 边/弧带权的图。 邻接: 有边/弧相连的两个顶点之间的关系。 存在(v, v)，则称v,和v互为邻接点; 存在<Vi; Vj>，则称vi邻接到vj,vj邻接于vi。 顶点的度: 与该顶点相关联的边的数目，记为TD(v)；在有向图中，顶点的度等于该顶点的入度与出度之和。顶点v的入
C语言数据结构代码——有向图
qq_41862220的博客
04-28 2482
Head.H #define VEXNUMMAX 10 typedef enum { DG = 0, DN, UDG, UDN }EnumGraphKind; typedef struct _ArcNode { int vex_index; struct _ArcNode *nextarc; }ArcNode,*arcnode; typedef struct _VexNode...
顺序表的插入操作数据结构c语言实现
05-20
顺序表的插入操作通常包括以下几个步骤： 1. 判断插入位置是否合法，即插入位置的下标是否在顺序表的范围内； 2. 如果插入位置不在顺序表的末尾，则需要将插入位置及其后面的元素依次向后移动一位，为新元素腾出位置； 3. 将新元素插入到顺序表的指定位置。 以下是一个简单的顺序表插入操作的 C 语言实现： ```c #include <stdio.h> #define MAXSIZE 100 // 定义顺序表的最大长度 typedef struct { int data[MAXSIZE]; // 存储元素的数组 int length; // 当前顺序表的长度 } SeqList; // 在顺序表中插入元素 x 到下标为 i 的位置 int insert(SeqList *L, int i, int x) { if (i < 1 || i > L->length+1 || L->length == MAXSIZE) { // 判断插入位置是否合法 return 0; // 插入失败 } for (int j = L->length; j >= i; j--) { // 将插入位置及其后面的元素依次向后移动一位 L->data[j] = L->data[j-1]; } L->data[i-1] = x; // 将新元素插入到顺序表的指定位置 L->length++; // 更新顺序表的长度 return 1; // 插入成功 } int main() { SeqList L = {{1, 3, 5, 7, 9}, 5}; // 初始化一个顺序表 int i = 3, x = 4; // 要在下标为 3 的位置插入元素 4 if (insert(&L, i, x)) { // 插入成功 printf("Insert %d at position %d success!\n", x, i); for (int j = 0; j < L.length; j++) { printf("%d ", L.data[j]); // 输出插入后的顺序表 } printf("\n"); } else { // 插入失败 printf("Insert %d at position %d failed!\n", x, i); } return 0; } ``` 运行结果为： ``` Insert 4 at position 3 success! 1 3 4 5 7 9 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值