《数据结构（C语言版）第二版》第六章-图（6.4 图的存储结构——链式存储——6.4.2 邻接表（稀疏图）、6.4.3 十字链表、6.4.4 邻接多重表）

已于 2024-08-16 16:56:44 修改
阅读量294 收藏 4
点赞数 2
分类专栏： 《数据结构（C语言版）第二版》 文章标签： 数据结构 c语言 开发语言 算法 c语言版
于 2024-08-13 14:20:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44883214/article/details/141162793
版权

6.4.2 邻接表（稀疏图）

采用邻接表表示法创建无向图

//算法6.2 采用邻接表表示法创建无向图

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

#define MVNum 100

typedef int OtherInfo;   //假设在边结点中的数据域存储边的权值,且边的权值类型为整型
typedef char VerTexType;  //假设顶点的数据类型为字符型

typedef struct ArcNode
{
	int adjvex;
	struct ArcNode* nextarc;
	OtherInfo info;
}ArcNode;  //边结点

typedef struct VNode
{
	VerTexType data;
	ArcNode* firstarc; 
}VNode,AdjList[MVNum];  //表头结点

typedef struct
{
	AdjList vertices;  //存储所有顶点
	int vexnum;  //顶点总数
	int arcnum;  //总边数
}ALGraph;  //图的信息

void CreateUDG(ALGraph& G);
int LocateVex(ALGraph& G, VerTexType v);
void printALGraph(ALGraph &G);

int main()
{
	ALGraph G = { {'\0',NULL}, 0,0};
	CreateUDG(G);
	printALGraph(G);

	return 0;
}

void CreateUDG(ALGraph& G)
{
	int i = 0;
	int k = 0;
	VerTexType v1 = 0;
	VerTexType v2 = 0;
	int j = 0;
	ArcNode *p1 = NULL;
	ArcNode *p2 = NULL;

	printf("请输入无向图的总顶点数：");
	scanf_s(" %d", &G.vexnum);

	printf("请输入无向图的总边数：");
	scanf_s(" %d", &G.arcnum);

	for (i = 0; i < G.vexnum; ++i)
	{
		printf("请输入第%d个顶点的值：", i + 1);
		scanf_s(" %c", &(G.vertices[i].data));
		G.vertices[i].firstarc = NULL;   //初始化
	}

	for (k = 0; k < G.arcnum; k++)
	{
		printf("请输入第%d条边依附的两个顶点（用空格间隔，输入结束后按回车）: ", k + 1);
		scanf_s(" %c %c", &v1, sizeof(VerTexType), &v2, sizeof(VerTexType)); 

		i = LocateVex(G, v1);
		j = LocateVex(G, v2);

		p1 = (ArcNode*)malloc(sizeof(ArcNode));
		p1->adjvex = j;
		p1->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = p1;  //将新结点*p1插入顶点Vi的边表头部

		p2 = (ArcNode*)malloc(sizeof(ArcNode));
		p2->adjvex = i;
		p2->nextarc = G.vertices[j].firstarc;
		G.vertices[j].firstarc = p2;  //将与*p1对称的新的边结点*p2插入顶点Vj的边表头部
	}
}


//在G的顶点表vexs中获取字符v的下标（数组G.vexs的下标从0开始）
int LocateVex(ALGraph& G, VerTexType v)
{
	int i = 0;
	for (i = 0; i < G.vexnum && (G.vertices[i].data != v); ++i)
	{
		;
	}

	return i;
}


//打印邻接表
void printALGraph(ALGraph& G)
{
	int i = 0;
	ArcNode* pMove = NULL;

	for (i = 0; i < G.vexnum; i++)
	{
		printf("\n第%d个顶点为：%c", i + 1, G.vertices[i].data);

		pMove = G.vertices[i].firstarc;
		if (pMove)
		{
			printf("\n与第%d个顶点相邻接的每个顶点在图中的位置（下标值）为：", i + 1);
			while (pMove)
			{
				printf("%d ", pMove->adjvex);
				pMove = pMove->nextarc;
			}
		}
		else
		{
			printf("\n没有与第%d个顶点相邻接的顶点。", i + 1);
		}
	}
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

一个图的邻接矩阵表示是唯一的，但其邻接表表示不唯一。

不改变图中每个顶点的命名方式，也不改变图的边（每条边的起终点），
仅改变边的输入次序时，图的邻接表中每个顶点后面边表中的结点排序方式会发生变化。
因为图中的顶点没变，边也没变，每个顶点及其边表中的内容不会发生变化。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

采用邻接表表示法创建有向图

//采用邻接表表示法创建有向图

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

#define MVNum 100

typedef int OtherInfo;   //假设在边结点中的数据域存储边的权值,且边的权值类型为整型
typedef char VerTexType;  //假设顶点的数据类型为字符型

typedef struct ArcNode
{
	int adjvex;
	struct ArcNode* nextarc;
	OtherInfo info;
}ArcNode;  //边结点

typedef struct VNode
{
	VerTexType data;
	ArcNode* firstarc;
}VNode, AdjList[MVNum];  //表头结点

typedef struct
{
	AdjList vertices;  //存储所有顶点
	int vexnum;  //顶点总数
	int arcnum;  //总边数
}ALGraph;  //图的信息

void CreateDG(ALGraph& G);
int LocateVex(ALGraph& G, VerTexType v);
void printALGraph(ALGraph& G);

int main()
{
	ALGraph G = { {'\0',NULL}, 0,0 };
	CreateDG(G);
	printALGraph(G);

	return 0;
}

//采用邻接表表示法创建有向图
void CreateDG(ALGraph& G)
{
	int i = 0;
	int k = 0;
	VerTexType v1 = 0;
	VerTexType v2 = 0;
	int j = 0;
	ArcNode* p1 = NULL;
	ArcNode* p2 = NULL;

	printf("请输入有向图的总顶点数：");
	scanf_s(" %d", &G.vexnum);

	printf("请输入有向图的总边数：");
	scanf_s(" %d", &G.arcnum);

	for (i = 0; i < G.vexnum; ++i)
	{
		printf("请输入第%d个顶点的值：", i + 1);
		scanf_s(" %c", &(G.vertices[i].data));
		G.vertices[i].firstarc = NULL;   //初始化
	}

	for (k = 0; k < G.arcnum; k++)
	{
		printf("请输入第%d条边依附的两个顶点（用空格间隔，输入结束后按回车）: ", k + 1);
		scanf_s(" %c %c", &v1, sizeof(VerTexType), &v2, sizeof(VerTexType));

		i = LocateVex(G, v1);
		j = LocateVex(G, v2);

		p1 = (ArcNode*)malloc(sizeof(ArcNode));
		p1->adjvex = j;
		p1->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = p1;  //将新结点*p1插入顶点Vi的边表头部
	}
}


//在G的顶点表vexs中获取字符v的下标（数组G.vexs的下标从0开始）
int LocateVex(ALGraph& G, VerTexType v)
{
	int i = 0;
	for (i = 0; i < G.vexnum && (G.vertices[i].data != v); ++i)
	{
		;
	}

	return i;
}


//打印邻接表
void printALGraph(ALGraph& G)
{
	int i = 0;
	ArcNode* pMove = NULL;

	for (i = 0; i < G.vexnum; i++)
	{
		printf("\n第%d个顶点为：%c", i + 1, G.vertices[i].data);

		pMove = G.vertices[i].firstarc;
		if (pMove)
		{
			printf("\n将第%d个顶点作为出度，与其相邻接的每个顶点在图中的位置（下标值）为：", i + 1);
			while (pMove)
			{
				printf("%d ", pMove->adjvex);
				pMove = pMove->nextarc;
			}
		}
		else
		{
			printf("\n将第%d个顶点作为出度，没有与其相邻接的顶点。", i + 1);
		}
	}
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

创建有向图的逆邻接表

//创建有向图的逆邻接表

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

#define MVNum 100

typedef int OtherInfo;   //假设在边结点中的数据域存储边的权值,且边的权值类型为整型
typedef char VerTexType;  //假设顶点的数据类型为字符型

typedef struct ArcNode
{
	int adjvex;
	struct ArcNode* nextarc;
	OtherInfo info;
}ArcNode;  //边结点

typedef struct VNode
{
	VerTexType data;
	ArcNode* firstarc;
}VNode, AdjList[MVNum];  //表头结点

typedef struct
{
	AdjList vertices;  //存储所有顶点
	int vexnum;  //顶点总数
	int arcnum;  //总边数
}ALGraph;  //图的信息

void CreateDG(ALGraph& G);
int LocateVex(ALGraph& G, VerTexType v);
void printALGraph(ALGraph& G);

int main()
{
	ALGraph G = { {'\0',NULL}, 0,0 };
	CreateDG(G);
	printALGraph(G);

	return 0;
}

//创建有向图的逆邻接表
void CreateDG(ALGraph& G)
{
	int i = 0;
	int k = 0;
	VerTexType v1 = 0;
	VerTexType v2 = 0;
	int j = 0;
	ArcNode* p1 = NULL;
	ArcNode* p2 = NULL;

	printf("请输入有向图的总顶点数：");
	scanf_s(" %d", &G.vexnum);

	printf("请输入有向图的总边数：");
	scanf_s(" %d", &G.arcnum);

	for (i = 0; i < G.vexnum; ++i)
	{
		printf("请输入第%d个顶点的值：", i + 1);
		scanf_s(" %c", &(G.vertices[i].data));
		G.vertices[i].firstarc = NULL;   //初始化
	}

	for (k = 0; k < G.arcnum; k++)
	{
		printf("请输入第%d条边依附的两个顶点（用空格间隔，输入结束后按回车）: ", k + 1);
		scanf_s(" %c %c", &v1, sizeof(VerTexType), &v2, sizeof(VerTexType));

		i = LocateVex(G, v1);
		j = LocateVex(G, v2);

		p1 = (ArcNode*)malloc(sizeof(ArcNode));
		p1->adjvex = i;
		p1->nextarc = G.vertices[j].firstarc;
		G.vertices[j].firstarc = p1;  //将新结点*p1插入顶点Vj的边表头部
	}
}


//在G的顶点表vexs中获取字符v的下标（数组G.vexs的下标从0开始）
int LocateVex(ALGraph& G, VerTexType v)
{
	int i = 0;
	for (i = 0; i < G.vexnum && (G.vertices[i].data != v); ++i)
	{
		;
	}

	return i;
}


//打印逆邻接表
void printALGraph(ALGraph& G)
{
	int i = 0;
	ArcNode* pMove = NULL;

	for (i = 0; i < G.vexnum; i++)
	{
		printf("\n第%d个顶点为：%c", i + 1, G.vertices[i].data);

		pMove = G.vertices[i].firstarc;
		if (pMove)
		{
			printf("\n将第%d个顶点作为入度，与其相邻接的每个顶点在图中的位置（下标值）为：", i + 1);
			while (pMove)
			{
				printf("%d ", pMove->adjvex);
				pMove = pMove->nextarc;
			}
		}
		else
		{
			printf("\n将第%d个顶点作为入度，没有与其相邻接的顶点。", i + 1);
		}
	}
}

在这里插入图片描述

在这里插入图片描述

采用邻接表表示法创建无向网

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

#define MVNum 100

typedef int OtherInfo;   //假设在边结点中的数据域存储边的权值,且边的权值类型为整型
typedef char VerTexType;  //假设顶点的数据类型为字符型

typedef struct ArcNode
{
	int adjvex;
	struct ArcNode* nextarc;
	OtherInfo info;
}ArcNode;  //边结点

typedef struct VNode
{
	VerTexType data;
	ArcNode* firstarc;
}VNode, AdjList[MVNum];  //表头结点

typedef struct
{
	AdjList vertices;  //存储所有顶点
	int vexnum;  //顶点总数
	int arcnum;  //总边数
}ALGraph;  //图的信息

void CreateUDN(ALGraph& G);
int LocateVex(ALGraph& G, VerTexType v);
void printALGraph(ALGraph& G);

int main()
{
	ALGraph G = { {'\0',NULL}, 0,0 };
	CreateUDN(G);
	printALGraph(G);

	return 0;
}

//采用邻接表表示法创建无向网
void CreateUDN(ALGraph& G)
{
	int i = 0;
	int k = 0;
	VerTexType v1 = 0;
	VerTexType v2 = 0;
	int j = 0;
	ArcNode* p1 = NULL;
	ArcNode* p2 = NULL;
	int w = 0;

	printf("请输入无向网的总顶点数：");
	scanf_s(" %d", &G.vexnum);

	printf("请输入无向网的总边数：");
	scanf_s(" %d", &G.arcnum);

	for (i = 0; i < G.vexnum; ++i)
	{
		printf("请输入第%d个顶点的值：", i + 1);
		scanf_s(" %c", &(G.vertices[i].data));
		G.vertices[i].firstarc = NULL;   //初始化
	}

	for (k = 0; k < G.arcnum; k++)
	{
		printf("请输入第%d条边依附的两个顶点（用空格间隔，输入结束后按回车）: ", k + 1);
		scanf_s(" %c %c", &v1, sizeof(VerTexType), &v2, sizeof(VerTexType));		
		printf("请输入第%d条边的权值 : ", k + 1);
		scanf_s(" %d", &w, sizeof(OtherInfo));

		i = LocateVex(G, v1);
		j = LocateVex(G, v2);

		p1 = (ArcNode*)malloc(sizeof(ArcNode));
		p1->adjvex = j;
		p1->info = w;
		p1->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = p1;  //将新结点*p1插入顶点Vi的边表头部

		p2 = (ArcNode*)malloc(sizeof(ArcNode));
		p2->adjvex = i;
		p1->info = w;
		p2->nextarc = G.vertices[j].firstarc;
		G.vertices[j].firstarc = p2;  //将与*p1对称的新的边结点*p2插入顶点Vj的边表头部
	}
}


//在G的顶点表vexs中获取字符v的下标（数组G.vexs的下标从0开始）
int LocateVex(ALGraph& G, VerTexType v)
{
	int i = 0;
	for (i = 0; i < G.vexnum && (G.vertices[i].data != v); ++i)
	{
		;
	}

	return i;
}


//打印邻接表
void printALGraph(ALGraph& G)
{
	int i = 0;
	ArcNode* pMove = NULL;

	for (i = 0; i < G.vexnum; i++)
	{
		printf("\n第%d个顶点为：%c", i + 1, G.vertices[i].data);

		pMove = G.vertices[i].firstarc;
		if (pMove)
		{
			printf("\n与第%d个顶点相邻接的每个顶点在网中的位置（下标值）为：", i + 1);
			while (pMove)
			{
				printf("%d ", pMove->adjvex);
				pMove = pMove->nextarc;
			}
		}
		else
		{
			printf("\n没有与第%d个顶点相邻接的顶点。", i + 1);
		}
	}
}

在这里插入图片描述

在这里插入图片描述

采用邻接表表示法创建有向网

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

#define MVNum 100

typedef int OtherInfo;   //假设在边结点中的数据域存储边的权值,且边的权值类型为整型
typedef char VerTexType;  //假设顶点的数据类型为字符型

typedef struct ArcNode
{
	int adjvex;
	struct ArcNode* nextarc;
	OtherInfo info;
}ArcNode;  //边结点

typedef struct VNode
{
	VerTexType data;
	ArcNode* firstarc;
}VNode, AdjList[MVNum];  //表头结点

typedef struct
{
	AdjList vertices;  //存储所有顶点
	int vexnum;  //顶点总数
	int arcnum;  //总边数
}ALGraph;  //图的信息

void CreateDN(ALGraph& G);
int LocateVex(ALGraph& G, VerTexType v);
void printALGraph(ALGraph& G);

int main()
{
	ALGraph G = { {'\0',NULL}, 0,0 };
	CreateDN(G);
	printALGraph(G);

	return 0;
}

//采用邻接表表示法创建有向网
void CreateDN(ALGraph& G)
{
	int i = 0;
	int k = 0;
	VerTexType v1 = 0;
	VerTexType v2 = 0;
	int j = 0;
	ArcNode* p1 = NULL;
	ArcNode* p2 = NULL;
	int w = 0;

	printf("请输入有向网的总顶点数：");
	scanf_s(" %d", &G.vexnum);

	printf("请输入有向网的总边数：");
	scanf_s(" %d", &G.arcnum);

	for (i = 0; i < G.vexnum; ++i)
	{
		printf("请输入第%d个顶点的值：", i + 1);
		scanf_s(" %c", &(G.vertices[i].data));
		G.vertices[i].firstarc = NULL;   //初始化
	}

	for (k = 0; k < G.arcnum; k++)
	{
		printf("请输入第%d条边依附的两个顶点（用空格间隔，输入结束后按回车）: ", k + 1);
		scanf_s(" %c %c", &v1, sizeof(VerTexType), &v2, sizeof(VerTexType));		
		printf("请输入第%d条边的权值 : ", k + 1);
		scanf_s(" %d", &w, sizeof(OtherInfo));

		i = LocateVex(G, v1);
		j = LocateVex(G, v2);

		p1 = (ArcNode*)malloc(sizeof(ArcNode));
		p1->adjvex = j;
		p1->info = w;
		p1->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = p1;  //将新结点*p1插入顶点Vi的边表头部
	}
}


//在G的顶点表vexs中获取字符v的下标（数组G.vexs的下标从0开始）
int LocateVex(ALGraph& G, VerTexType v)
{
	int i = 0;
	for (i = 0; i < G.vexnum && (G.vertices[i].data != v); ++i)
	{
		;
	}

	return i;
}


//打印邻接表
void printALGraph(ALGraph& G)
{
	int i = 0;
	ArcNode* pMove = NULL;

	for (i = 0; i < G.vexnum; i++)
	{
		printf("\n第%d个顶点为：%c", i + 1, G.vertices[i].data);

		pMove = G.vertices[i].firstarc;
		if (pMove)
		{
			printf("\n将第%d个顶点作为出度，与其相邻接的每个顶点在网中的位置（下标值）为：", i + 1);
			while (pMove)
			{
				printf("%d ", pMove->adjvex);
				pMove = pMove->nextarc;
			}
		}
		else
		{
			printf("\n将第%d个顶点作为出度，没有与第%d个顶点相邻接的顶点。", i + 1);
		}
	}
}

在这里插入图片描述

在这里插入图片描述

创建有向网的逆邻接表

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

#define MVNum 100

typedef int OtherInfo;   //假设在边结点中的数据域存储边的权值,且边的权值类型为整型
typedef char VerTexType;  //假设顶点的数据类型为字符型

typedef struct ArcNode
{
	int adjvex;
	struct ArcNode* nextarc;
	OtherInfo info;
}ArcNode;  //边结点

typedef struct VNode
{
	VerTexType data;
	ArcNode* firstarc;
}VNode, AdjList[MVNum];  //表头结点

typedef struct
{
	AdjList vertices;  //存储所有顶点
	int vexnum;  //顶点总数
	int arcnum;  //总边数
}ALGraph;  //图的信息

void CreateDN(ALGraph& G);
int LocateVex(ALGraph& G, VerTexType v);
void printALGraph(ALGraph& G);

int main()
{
	ALGraph G = { {'\0',NULL}, 0,0 };
	CreateDN(G);
	printALGraph(G);

	return 0;
}

//创建有向网的逆邻接表
void CreateDN(ALGraph& G)
{
	int i = 0;
	int k = 0;
	VerTexType v1 = 0;
	VerTexType v2 = 0;
	int j = 0;
	ArcNode* p1 = NULL;
	ArcNode* p2 = NULL;
	int w = 0;

	printf("请输入有向网的总顶点数：");
	scanf_s(" %d", &G.vexnum);

	printf("请输入有向网的总边数：");
	scanf_s(" %d", &G.arcnum);

	for (i = 0; i < G.vexnum; ++i)
	{
		printf("请输入第%d个顶点的值：", i + 1);
		scanf_s(" %c", &(G.vertices[i].data));
		G.vertices[i].firstarc = NULL;   //初始化
	}

	for (k = 0; k < G.arcnum; k++)
	{
		printf("请输入第%d条边依附的两个顶点（用空格间隔，输入结束后按回车）: ", k + 1);
		scanf_s(" %c %c", &v1, sizeof(VerTexType), &v2, sizeof(VerTexType));
		printf("请输入第%d条边的权值 : ", k + 1);
		scanf_s(" %d", &w, sizeof(OtherInfo));

		i = LocateVex(G, v1);
		j = LocateVex(G, v2);

		p1 = (ArcNode*)malloc(sizeof(ArcNode));
		p1->adjvex = i;
		p1->info = w;
		p1->nextarc = G.vertices[j].firstarc;
		G.vertices[j].firstarc = p1;  //将新结点*p1插入顶点Vj的边表头部
	}
}


//在G的顶点表vexs中获取字符v的下标（数组G.vexs的下标从0开始）
int LocateVex(ALGraph& G, VerTexType v)
{
	int i = 0;
	for (i = 0; i < G.vexnum && (G.vertices[i].data != v); ++i)
	{
		;
	}

	return i;
}


//打印逆邻接表
void printALGraph(ALGraph& G)
{
	int i = 0;
	ArcNode* pMove = NULL;

	for (i = 0; i < G.vexnum; i++)
	{
		printf("\n第%d个顶点为：%c", i + 1, G.vertices[i].data);

		pMove = G.vertices[i].firstarc;
		if (pMove)
		{
			printf("\n将第%d个顶点作为入度，与其相邻接的每个顶点在网中的位置（下标值）为：", i + 1);
			while (pMove)
			{
				printf("%d ", pMove->adjvex);
				pMove = pMove->nextarc;
			}
		}
		else
		{
			printf("\n将第%d个顶点作为入度，没有与第%d个顶点相邻接的顶点。", i + 1);
		}
	}
}

在这里插入图片描述

6.4.3 十字链表

采用十字链表表示法创建有向图

//采用十字链表表示法创建有向图

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

#define MAX_VERTEX_NUM  20

typedef int InfoType;   //假设在边结点中的数据域存储边的权值,且边的权值类型为整型
typedef char VerTexType;  //假设顶点的数据类型为字符型

typedef struct ArcBox
{
	int tailvex;
	int headvex;
	struct ArcBox* hlink;
	struct ArcBox* tlink; 
	InfoType *info;
}ArcBox;  

typedef struct VexNode
{
	VerTexType data;
	ArcBox *firstin;
	ArcBox *firstout;
}VexNode; 

typedef struct
{
	VexNode xlist[MAX_VERTEX_NUM];  //表头向量
	int vexnum;  //顶点总数
	int arcnum;  //总边数
}OLGraph;  //图的信息

void CreateOLGraph(OLGraph& G);
int LocateVex(OLGraph& G, VerTexType v);
void printOLGraph(OLGraph& G);

int main()
{
	OLGraph G = { {'\0',NULL,NULL}, 0,0 };
	CreateOLGraph(G);
	printOLGraph(G);

	return 0;
}

//采用十字链表表示法创建有向图
void CreateOLGraph(OLGraph& G)
{
	int i = 0;
	int j = 0;
	int k = 0;
	VerTexType v1 = 0;
	VerTexType v2 = 0;
	ArcBox* p1 = NULL;


	printf("请输入有向图的总顶点数：");
	scanf_s(" %d", &G.vexnum);

	printf("请输入有向图的总边数：");
	scanf_s(" %d", &G.arcnum);

	for (i = 0; i < G.vexnum; ++i)
	{
		printf("请输入第%d个顶点的值：", i + 1);
		scanf_s(" %c", &(G.xlist[i].data));
		G.xlist[i].firstin = NULL;
		G.xlist[i].firstout = NULL;//初始化
	}

	for (k = 0; k < G.arcnum; k++)
	{
		printf("请输入第%d条弧依附的两个顶点（用空格间隔，输入结束后按回车）: ", k + 1);
		scanf_s(" %c %c", &v1, sizeof(VerTexType), &v2, sizeof(VerTexType));
		//起点v1是弧尾，终点v2是弧头
		//弧<v1,v2>是v1的出度，是v2的入度

		i = LocateVex(G, v1);
		j = LocateVex(G, v2);
		//起点v1是弧尾，下标值为i；终点v2是弧头，下标值为j
		//弧<v1,v2>是第i+1个顶点的出度firstout，是第j+1个顶点的入度firstin

		p1 = (ArcBox*)malloc(sizeof(ArcBox));

		p1->tailvex = i;  //起点v1是弧尾，下标值为i
		p1->headvex = j;   //终点v2是弧头，下标值为j

		//p1弧结点中的链域tlink指向与其弧尾tailvext相同的下一条弧（即指向第i+1个顶点v1的下一个出度firstout）
		p1->tlink = G.xlist[i].firstout;  //p1指向的弧<v1,v2>是第i+1个顶点v1的出度firstout
		G.xlist[i].firstout = p1;   //前插法将p1插入到第i+1个顶点v1的出度单链表中

		//p1弧结点中的链域hlink指向与其弧头headvex相同的下一条弧（即指向第j+1个顶点v2的下一个入度firstin）
		p1->hlink = G.xlist[j].firstin;   //p1指向的弧<v1,v2>是第j+1个顶点v2的入度firstin
		G.xlist[j].firstin = p1;  //前插法将p1插入到第j+1个顶点v2的入度单链表中
	}
}


//在G的顶点表xlist中获取字符v的下标（数组G.xlist的下标从0开始）
int LocateVex(OLGraph& G, VerTexType v)
{
	int i = 0;
	for (i = 0; i < G.vexnum && (G.xlist[i].data != v); ++i)
	{
		;
	}

	return i;
}


//打印十字链表
void printOLGraph(OLGraph& G)
{
	int i = 0;
	ArcBox* pMoveIn = NULL;
	ArcBox* pMoveOut = NULL;

	for (i = 0; i < G.vexnum; i++)
	{
		printf("\n第%d个顶点为：%c", i + 1, G.xlist[i].data);

		pMoveOut = G.xlist[i].firstout;
		if (pMoveOut)
		{
			printf("\n将第%d个顶点作为出度，与其相邻接的每个顶点在图中的位置（下标值）为：", i + 1);
			while (pMoveOut)
			{
				printf("%d ", pMoveOut->headvex);
				pMoveOut = pMoveOut->tlink;
			}
		}
		else
		{
			printf("\n将第%d个顶点作为出度，没有与其相邻接的顶点。", i + 1);
		}


		pMoveIn = G.xlist[i].firstin;
		if (pMoveIn)
		{
			printf("\n将第%d个顶点作为入度，与其相邻接的每个顶点在图中的位置（下标值）为：", i + 1);
			while (pMoveIn)
			{
				printf("%d ", pMoveIn->tailvex);
				pMoveIn = pMoveIn->hlink;
			}
		}
		else
		{
			printf("\n将第%d个顶点作为入度，没有与其相邻接的顶点。", i + 1);
		}

	}
}

在这里插入图片描述
在这里插入图片描述

该有向图的邻接矩阵，其中各行、各列中不为0的元素，与其十字链表每个顶点的出度、入度结果有对应关系。
在这里插入图片描述

采用十字链表表示法创建有向网

输入并读取权值，赋值到 弧结点 ArcBox 结构中的 info 成员即可。

//采用十字链表表示法创建有向网

void CreateOLGraph(OLGraph& G)
{
	int i = 0;
	int j = 0;
	int k = 0;
	VerTexType v1 = 0;
	VerTexType v2 = 0;
	ArcBox* p1 = NULL;

	int* w = 0;

	printf("请输入有向网的总顶点数：");
	scanf_s(" %d", &G.vexnum);

	printf("请输入有向网的总边数：");
	scanf_s(" %d", &G.arcnum);

	for (i = 0; i < G.vexnum; ++i)
	{
		printf("请输入第%d个顶点的值：", i + 1);
		scanf_s(" %c", &(G.xlist[i].data));
		G.xlist[i].firstin = NULL;
		G.xlist[i].firstout = NULL;//初始化
	}

	for (k = 0; k < G.arcnum; k++)
	{
		printf("请输入第%d条弧依附的两个顶点（用空格间隔，输入结束后按回车）: ", k + 1);
		scanf_s(" %c %c", &v1, sizeof(VerTexType), &v2, sizeof(VerTexType));

		printf("请输入第%d条边的权值 : ", k + 1);
		scanf_s(" %d", w, sizeof(InfoType));  //在ArcBox中，info由指向int的指针定义

		i = LocateVex(G, v1);
		j = LocateVex(G, v2);

		p1 = (ArcBox*)malloc(sizeof(ArcBox));

		p1->tailvex = i; 
		p1->headvex = j;  

		p1->info = w;  //赋值到弧结点p1中的info成员

		p1->tlink = G.xlist[i].firstout;  
		G.xlist[i].firstout = p1;   

		p1->hlink = G.xlist[j].firstin;   
		G.xlist[j].firstin = p1;  
	}
}

6.4.4 邻接多重表

采用邻接多重表表示法创建无向图

//采用邻接多重表表示法创建无向图

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

#define MAX_VERTEX_NUM  20

typedef enum {unvisited,visited} VisitIf;
typedef int InfoType;   //假设在边结点中的数据域存储边的权值,且边的权值类型为整型
typedef char VerTexType;  //假设顶点的数据类型为字符型

typedef struct EBox
{
	VisitIf mark;
	int ivex;
	int jvex;
	struct EBox* ilink;
	struct EBox* jlink; 
	InfoType *info;
}EBox;  

typedef struct VexBox
{
	VerTexType data;
	EBox* firstedge;
}VexBox; 

typedef struct
{
	VexBox adjmulist[MAX_VERTEX_NUM];  //表头向量
	int vexnum;  //顶点总数
	int edgenum;  //总边数
}AMLGraph;  //图的信息

void CreateAMLGraph(AMLGraph& G);
int LocateVex(AMLGraph& G, VerTexType v);
void printAMLGraph(AMLGraph& G);

int main()
{
	AMLGraph G = { {'\0',NULL,NULL}, 0,0 };
	CreateAMLGraph(G);
	printAMLGraph(G);

	return 0;
}

//采用邻接多重表表示法创建无向图
void CreateAMLGraph(AMLGraph& G)
{
	int i = 0;
	int j = 0;
	int k = 0;
	VerTexType v1 = 0;
	VerTexType v2 = 0;
	EBox* p1 = NULL;

	printf("请输入无向图的总顶点数：");
	scanf_s(" %d", &G.vexnum);

	printf("请输入无向图的总边数：");
	scanf_s(" %d", &G.edgenum);

	for (i = 0; i < G.vexnum; ++i)
	{
		printf("请输入第%d个顶点的值：", i + 1);
		scanf_s(" %c", &(G.adjmulist[i].data));
		G.adjmulist[i].firstedge = NULL;  //初始化
	}

	for (k = 0; k < G.edgenum; k++)
	{
		printf("请输入第%d条弧依附的两个顶点（用空格间隔，输入结束后按回车）: ", k + 1);
		scanf_s(" %c %c", &v1, sizeof(VerTexType), &v2, sizeof(VerTexType));
		
		i = LocateVex(G, v1);
		j = LocateVex(G, v2);

		p1 = (EBox*)malloc(sizeof(EBox));

		p1->ivex = i; 
		p1->jvex = j;  

		p1->ilink = G.adjmulist[i].firstedge;
		G.adjmulist[i].firstedge = p1;

		p1->jlink = G.adjmulist[j].firstedge;
		G.adjmulist[j].firstedge = p1;
	}
}


//在G的顶点表adjmulist中获取字符v的下标（数组G.xlist的下标从0开始）
int LocateVex(AMLGraph& G, VerTexType v)
{
	int i = 0;
	for (i = 0; i < G.vexnum && (G.adjmulist[i].data != v); ++i)
	{
		;
	}

	return i;
}


//打印邻接多重表
void printAMLGraph(AMLGraph& G)
{
	int i = 0;
	EBox* pMove = NULL;

	for (i = 0; i < G.vexnum; i++)
	{
		printf("\n第%d个顶点为：%c", i + 1, G.adjmulist[i].data);
		pMove = G.adjmulist[i].firstedge;

		if (pMove)
		{
			printf("\n与第%d个顶点相邻接的每个顶点在图中的位置（下标值）为：", i + 1);
			while (pMove)
			{
				if (pMove->ivex == i)
				{
					printf("%d ", pMove->jvex);
					pMove = pMove->ilink;
				}
				else if (pMove->jvex == i)
				{
					printf("%d ", pMove->ivex);
					pMove = pMove->jlink;
				}
			}
		}
		else
		{
			printf("\n没有与第%d个顶点相邻接的顶点。", i + 1);
		}	
	}
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

采用邻接多重表表示法创建无向网

输入并读取权值，赋值到 边结点 EBox 结构中的 info 成员即可。

//采用邻接多重表表示法创建无向网
void CreateAMLGraph(AMLGraph& G)
{
	int i = 0;
	int j = 0;
	int k = 0;
	VerTexType v1 = 0;
	VerTexType v2 = 0;
	EBox* p1 = NULL;

	int* w = 0;

	printf("请输入无向网的总顶点数：");
	scanf_s(" %d", &G.vexnum);

	printf("请输入无向网的总边数：");
	scanf_s(" %d", &G.edgenum);

	for (i = 0; i < G.vexnum; ++i)
	{
		printf("请输入第%d个顶点的值：", i + 1);
		scanf_s(" %c", &(G.adjmulist[i].data));
		G.adjmulist[i].firstedge = NULL;  //初始化
	}

	for (k = 0; k < G.edgenum; k++)
	{
		printf("请输入第%d条弧依附的两个顶点（用空格间隔，输入结束后按回车）: ", k + 1);
		scanf_s(" %c %c", &v1, sizeof(VerTexType), &v2, sizeof(VerTexType));

		printf("请输入第%d条边的权值 : ", k + 1);
		scanf_s(" %d", w, sizeof(InfoType));  //在EBox中，info由指向int的指针定义 

		i = LocateVex(G, v1);
		j = LocateVex(G, v2);

		p1 = (EBox*)malloc(sizeof(EBox));

		p1->ivex = i; 
		p1->jvex = j;  

		p1->info = w;   //赋值到边结点p1中的info成员

		p1->ilink = G.adjmulist[i].firstedge;
		G.adjmulist[i].firstedge = p1;

		p1->jlink = G.adjmulist[j].firstedge;
		G.adjmulist[j].firstedge = p1;
	}
}
Flerken101
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——第六章 图
疯子书生的博客
10-02 711
[知识框架] 主要掌握深度优先搜索和广度优先搜索，图的基本概念及基本性质、图的存储结构（邻接矩阵、邻接表、邻接多重表和十字链表）及其特性、存储结构之间的转化、基于存储结构上的遍历操作和各种应用（拓扑排序、最小生成树、最短路径和关键路径）等。通常要求掌握基本思想和实现步骤（手动模拟）。 6.1 图的基本概念 6.1.1 图的定义 图 GGG 由顶点集 VVV 和边集 EEE 组成，记为 G=(V,E)G=(V, E)G=(V,E) 。 其中 V(G)V(G)V(G) 表示图 GGG 中顶点的有限非空集; E
严蔚敏 数据结构(C语言版) 代码 23490 书中算法
04-21
6.2.2　邻接表　132 6.3　图的遍历　135 6.3.1　深度优先搜索　135 6.3.2　广度优先搜索　138 6.4　图的应用　139 6.4.1　最小生成树　139 6.4.2　最短路径　144 6.4.3　拓扑排序　150 6.4.4　关键路径　153 6.5　小...
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
热门推荐
chongyang_的博客
11-07 26万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
6.4 数据结构——图的存储结构之十字链表及邻接多重表
weixin_45523296的博客
10-30 505
图的存储结构之十字链表及邻接多重表
数据结构 第六章 图——图的定义和存储类型
weixin_62917800的博客
07-10 764
图
C语言数据结构【手抄版】第六章 图【下篇】
难拳的博客
05-06 205
1.熟悉图的有关术语和概念。 2.熟练掌握图的两种存储结构，并能根据问题的要求选择合适的存储结构。 3.熟练掌握图的深度优先和广度优先遍历算法。 4.理解生成树和最小生成树的概念，理解Prim和Kruskal算法的基本思想，并能够对给定的连通图，构造最小生成树。 5.理解和掌握求最短路径的Djkstra算法的基本思想，并能根据给定的有向图画出求单源最短路径的过程示意图。 6.理解拓扑排序的基本思想和步骤，能够对给定的有向图，写出图的拓扑排序序列。
数据结构 C语言版|第2版-复习
Villin尼的博客
05-30 3404
数据结构 C语言版|第2版-复习 目录数据结构 C语言版|第2版-复习第1章 绪论第2章 线性表第3章 栈和队列第4章 串、数组和广义表 第1章 绪论 1.2基本概念和术语 1.2.1数据、数据元素、数据项和数据对象 数据是客观事物的符号表示，是所有能输入到计算机中并被计算机程序处理的符号的总称。 数据元素是数据的基本单位。数据元素通常用于完整地描述一个对象。例如一名学生记录。 数据项是组成数据元素的、有独立含义的、不可分割的最小单位。例如学生基本信息表中的学号、姓名、性别等。 数据对象是性质相同的数据元素
王道数据结构课代表 - 考研数据结构 第六章 图 究极精华总结笔记
clzZ2的博客
01-18 3903
数据结构与算法 笔记导航🚥🚥🚥 🥬 第一章 绪论 🥕 第二章 线性表 🥪 第三章 栈和队列 🍊 第四章 串-KMP(看毛片算法) 🍒 第五章 树和二叉树 🍀 第六章 图 🍚 第七章 查找(B树、散列表) 🧄 第八章 排序 (内部排序：八大排序动图演示与实现 + 外部排序) 🍔 数据结构与算法 复试精简笔记 🎨 408 全套初复试笔记汇总 传送门 🏃‍🏃‍🏃‍ 如果本篇文章对大家起到帮助的话，跪求各位帅哥美女们，求赞👍 、求收藏、求关注！
6.4-图的储存结构与创建-总结-《数据结构第2版（严蔚敏）》
Tomino的博客
11-18 410
6.4图的存储结构与创建 存储结构 便于判断是否有边 便于计算度 便于增删 利用空间 统计边数 邻接矩阵 √ √ × × × 邻接表 × × √ √ √ 十字链表 √ √ √ √ 邻接多重表 √ √ √ √ 6.4.1 邻接矩阵（Adjacency Matrix） /ə’dʒeɪsənsɪ/ /ˈmeɪtrɪks/ 边edge、aec 顶点vertex 1、存储 #define MAX_INT 32767 //int在32位中能取得的最大值表示∞，64位中为 2,14
数据结构——第六章《图》
WBushYdc的博客
10-15 228
图G由顶点集V和边集E组成，记为G=（V，E），其中VG）表示图G中顶点的有限非空集：E（G）表示图G中顶点之间的关系（边）集合。若V=(V1uV2…，Va]，则用|V表示图G中顶点的个数，也称图G的阶，E={(u,v)I ueV,veV，用|E|表示图G中边的条数。注意：线性表可以是空表，树可以是空树，但图不可以是空，即V一定是非空集。
数据结构 c语言版
12-30
数据结构在很多地方用的到，在计算机行业，很有用的 。 第1章 绪论 1.1 什么是数据结构 1.2 基本概念和术语 1.3 抽象数据类型的表现与实现 1.4 算法和算法分析 第2章 线性表 2.1 线性表的类型定义 2.2 线性表...
《数据结构》（C语言版）严蔚敏
08-31
《数据结构》（C语言版）是为“数据结构”课程编写的教材，也可作为学习数据结构及其算法的C程序设计的参数教材。学了数据结构后,许多以前写起来很繁杂的代码现在写起来很清晰明了. 本书的前半部分从抽象数据类型的...
图解大顶堆的构建、排序过程
sagima_sdu的博客
08-12 487
开始，
【长度最小的子数组】python刷题记录
m0_73629042的博客
08-12 222
【代码】【长度最小的子数组】python刷题记录。
数据结构与算法--线索二叉树与哈夫曼树
wumingzei的博客
08-12 635
/ 标记枚举类型，Link表示指向孩子，Thread表示线索char data;// 结点数据域// 左右标记域// 左右孩子或线索// 定义线索二叉树结点类型哈夫曼树（最优二叉树）是带权路径长度WPL最小的二叉树。结点的权：将树中结点赋予一个有某种意义的数值。
数据结构——排序算法
2301_80373479的博客
08-13 1125
万字解析各大排序，带你领略你未曾了解的细节。
链表 19.删除链表的倒数第N个节点 双指针
最新发布
qq_64633597的博客
08-14 136
return head 和return dummy.next 的区别，若删除的是头节点，则头节点还需要更新，题目中给的头节点就不能用了。而dummy作为虚拟头节点，永远是头节点的上一位，即使head发生变化，仍然是dummy.next。fast走n+1步，是为了和slow保持n+1个位置，此时fast移动至空节点，slow与fast位置差n+1节点，那slow再往后移动一位，就是需要删除的倒数第n个节点，即目标节点。倒数第几个，翻过来看即正数第几个。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值