数据结构(16)--图的存储及实现

参考书籍：数据结构（C语言版）严蔚敏吴伟民编著清华大学出版社    

本文中的代码可从这里下载：https://github.com/qingyujean/data-structure

    图状结构是一种比树形结构更复杂的非线性结构。在树状结构中，结点间具有分支层次关系，每一层上的结点只能和上一层中的至多一个结点相关，但可能和下一层的多个结点相关。而在图状结构中，任意两个结点之间都可能相关，即结点之间的邻接关系可以是任意的。

1.邻接矩阵

1.1结构定义

    图和树一样，没有顺序映像的存储结构，但可以借助数组的数据类型表示元素之间的关系。所以邻接矩阵是用于描述图中顶点之间关系(即弧或边的权)的矩阵。   假设图中顶点数为n，则邻接矩阵An×n：

                1    若Vi和Vj之间有弧或边
    A[i][j]=
                0    反之
    
    网的邻接矩阵An×n：
                w （权值）          若Vi和Vj之间有弧或边
    A[i][j]=
                无穷大                   反之

注意：
1) 图中无邻接到自身的弧，因此邻接矩阵主对角线为全零。
2) 无向图的邻接矩阵必然是对称矩阵。
3) 无向图中，顶点的度是邻接矩阵对应行（或列）的非零元素之和；有向图中，对应行的非零元素之和是该顶点的出度；对应列的非零元素之和是该顶点的入度；则该顶点的度是对应行和对应列的非零元素之和。

1.2示例

以有向网示例：

1.3代码实现

 

#include<stdio.h>
//#include<stdlib.h>
/*
图的表示方法
DG（有向图）或者DN（有向网）：邻接矩阵、邻接表（逆邻接表--为求入度）、十字链表
UDG（无向图）或者UDN（无向网）：邻接矩阵、邻接表、邻接多重表
*/

//1.数组表示法（邻接矩阵）：将以有向网为例
#define INFINITY 32767//最大值：假定为无穷大
#define MAX_VERTEX_NUM 10//最大顶点数目
//typedef enum GraphKind {DG, DN, UDG, UDN};  //有向图：0，有向网：1，无向图：2，无向网：3

typedef int VRType;//顶点关系类型，对于无权图或网，用0或1表示相邻否；对于带权图或网，则为相应权值
typedef int VertexType;//顶点类型
typedef VRType AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct{
	VertexType vexs[MAX_VERTEX_NUM];//顶点向量
	AdjMatrix arcs;//邻接矩阵
	int vexnum, arcnum;//图的当前顶点数和弧数
	//GraphKind kind;//图的种类标志
}MGraph;//邻接矩阵表示的图

//若图G中存在顶点v，则返回v在图中的位置信息，否则返回其他信息
int locateVex(MGraph G, VertexType v){
	for(int i = 0; i < G.vexnum; i++){
		if(G.vexs[i] == v)
			return i;
	}
	return -1;//图中没有该顶点
}

//采用邻接矩阵表示法构造有向网G
void createDN(MGraph &G){
	printf("输入顶点数和弧数如:(5,3):");
	scanf("%d,%d", &G.vexnum, &G.arcnum);

	//构造顶点向量
	printf("输入%d个顶点（以空格隔开如：v1 v2 v3）:", G.vexnum);
	getchar();//吃掉换行符
	for(int m = 0; m < G.vexnum; m++){
		scanf("v%d", &G.vexs[m]);
		getchar();//吃掉空格符
	}

	
	//初始化邻接矩阵
	int i=0, j=0;
	for(i = 0; i < G.vexnum; i++){
		for(j = 0; j < G.vexnum; j++)
			G.arcs[i][j] = INFINITY;
	}

	//构造邻接矩阵
	VertexType v1, v2;//分别是一条弧的弧尾和弧头（起点和终点）
	VRType w;//对于无权图或网，用0或1表示相邻否；对于带权图或网，则为相应权值	
	printf("\n每行输入一条弧依附的顶点（先弧尾后弧头）和权值（如：v1 v2 3）:\n");
	fflush(stdin);//清除残余后，后面再读入时不会出错
	for(int k = 0; k < G.arcnum; k++){
		scanf("v%d v%d %d",&v1, &v2, &w);
		fflush(stdin);//清除残余后，后面再读入时不会出错
		i = locateVex(G, v1);
		j = locateVex(G, v2);
		G.arcs[i][j] = w;
	}
}

//打印邻接矩阵
void printDN(MGraph G){
	printf("\n打印有向网G的邻接矩阵：\n");
	for(int i = 0; i < G.vexnum; i++){
		for(int j = 0; j < G.vexnum; j++)
		{
			if(G.arcs[i][j] != INFINITY)
				printf("%9d ", G.arcs[i][j]);
			else
				printf("INFINITY  ");
		}
		printf("\n");
	}
	printf("\n");
}

 

1.4演示

 

 

/*测试：
6,10
v1 v2 v3 v4 v5 v6

v1,v2,5
v1,v4,7

v2,v3,4

v3,v1,8
v3,v6,9

v4,v3,5
v4,v6,6

v5,v4,5

v6,v1,3
v6,v5,1
*/
void main(){
	MGraph G;
	createDN(G);	
	printDN(G);
}

 

 

 

 

 

2.邻接表

 

2.1结构定义

类似树的孩子链表。即对图中的每个顶点vi建立一个单链表，表中结点表示依附于该顶点vi的边或弧。           

          弧结点                                                                                         顶点结点（弧链表表头结点）

                                                       

注意：
在无向图的邻接表中，
1）第i个链表中结点数目为顶点i的度；
2）所有链表中结点数目的一半为图中边数；
3）占用的存储单元数目为n+2e。
在有向图的邻接表中，
1）第i个链表中结点数目为顶点i的出度；
2）所有链表中结点数目为图中弧数；
3）占用的存储单元数目为n+e。

为求出每一个顶点的入度，必须另外建立有向图的逆邻接表。有向图的逆邻接表与邻接表类似，只是它是从入度考虑结点，而不是从出度考虑结点。

2.2示例

以无向网示例：

          

2.3代码实现

 

#include<stdio.h>
#include<stdlib.h>
/*
图的表示方法
DG（有向图）或者DN（有向网）：邻接矩阵、邻接表（逆邻接表--为求入度）、十字链表
UDG（无向图）或者UDN（无向网）：邻接矩阵、邻接表、邻接多重表
*/
#define MAX_VERTEX_NUM 10//最大顶点数目
#define NULL 0
typedef int VRType;//对于带权图或网，则为相应权值
typedef int VertexType;//顶点类型
//typedef enum GraphKind {DG, DN, UDG, UDN};  //有向图：0，有向网：1，无向图：2，无向

typedef struct ArcNode{	
	int adjvex;//该弧所指向的顶点的在图中位置
	VRType w;//弧的相应权值
	struct ArcNode *nextarc;//指向下一条弧的指针
}ArcNode;//弧结点信息

typedef struct VNode{
	VertexType data;//顶点信息
	ArcNode *firstarc;//指向第一条依附该顶点的弧的指针
}VNode, AdjVexList[MAX_VERTEX_NUM];//顶点结点信息

typedef struct{
	AdjVexList vexs;//顶点向量
	int vexnum, arcnum;//图的当前顶点数和弧数
	//GraphKind kind;//图的种类标志
}ALGraph;//邻接表表示的图

//若图G中存在顶点v，则返回v在图中的位置信息，否则返回其他信息
int locateVex(ALGraph G, VertexType v){
	for(int i = 0; i < G.vexnum; i++){
		if(G.vexs[i].data == v)
			return i;
	}
	return -1;//图中没有该顶点
}

//采用邻接表表示法构造无向网G
void createUDN(ALGraph &G){
	printf("输入顶点数和弧数如:(5,3):");
	scanf("%d,%d", &G.vexnum, &G.arcnum);

	//构造顶点向量,并初始化
	printf("输入%d个顶点（以空格隔开如：v1 v2 v3）:", G.vexnum);
	getchar();//吃掉换行符
	for(int m = 0; m < G.vexnum; m++){
		scanf("v%d", &G.vexs[m].data);
		G.vexs[m].firstarc = NULL;//初始化为空指针////////////////重要！！！
		getchar();//吃掉空格符
	}

	//构造邻接表
	VertexType v1, v2;//分别是一条弧的弧尾和弧头（起点和终点）
	VRType w;//对于无权图或网，用0或1表示相邻否；对于带权图或网，则为相应权值	
	printf("\n每行输入一条弧依附的顶点（先弧尾后弧头）和权值（如：v1 v2 3）:\n");
	fflush(stdin);//清除残余后，后面再读入时不会出错
	int i = 0, j = 0;
	for(int k = 0; k < G.arcnum; k++){
		scanf("v%d v%d %d",&v1, &v2, &w);
		fflush(stdin);//清除残余后，后面再读入时不会出错
		i = locateVex(G, v1);//弧起点
		j = locateVex(G, v2);//弧终点
		
		//采用“头插法”在各个顶点的弧链头部插入弧结点
		ArcNode *p1 = (ArcNode *)malloc(sizeof(ArcNode));//构造一个弧结点，作为弧vivj的弧头（终点）
		p1->adjvex = j;
		p1->w = w;
		p1->nextarc = G.vexs[i].firstarc;
		G.vexs[i].firstarc = p1;
		ArcNode *p2 = (ArcNode *)malloc(sizeof(ArcNode));//构造一个弧结点，作为弧vivj的弧尾（起点）
		p2->adjvex = i;
		p2->w = w;
		p2->nextarc = G.vexs[j].firstarc;
		G.vexs[j].firstarc = p2;
	}
}

//打印邻接表
void printAdjList(ALGraph G){
	printf("\n");
	for(int i = 0; i < G.vexnum; i++){
		printf("依附顶点v%d的弧为：", G.vexs[i].data);
		ArcNode *p = G.vexs[i].firstarc;
		while(p){
			printf("v%dv%d(weight:%d) ", G.vexs[i].data, G.vexs[p->adjvex].data, p->w);
			p = p->nextarc;
		}
		printf("\n");
	}
	printf("\n");
}

 

2.4演示

 

 

/*测试：
4,4
v1 v2 v3 v4

v1 v2 3
v1 v3 6
v1 v4 4
v2 v4 9
*/
void main(){
	ALGraph G;
	createUDN(G);
	printAdjList(G);
}

 

 

 

 

 

3.邻接多重表

 

3.1结构定义

 

    在无向图的邻接表中，每条边（Vi，Vj）由两个结点表示，一个结点在第 i 个链表中，另一个结点在第 j 个链表中，当需要对边进行操作时，就需找到表示同一条边的两个结点，这给操作带来不便，在这种情况下采用邻接多重表较方便。
    邻接多重表中结点分为：边结点和顶点结点 ：         

           弧结点                                                                                         顶点结点（弧链表表头结点）

                         

3.2示例

以无向图示例：

3.3代码实现

 

#include<stdio.h>
#include<stdlib.h>
/*
图的表示方法
DG（有向图）或者DN（有向网）：邻接矩阵、邻接表（逆邻接表--为求入度）、十字链表
UDG（无向图）或者UDN（无向网）：邻接矩阵、邻接表、邻接多重表
*/
#define MAX_VERTEX_NUM 10//最大顶点数目
#define NULL 0
//typedef int VRType;//对于带权图或网，则为相应权值
typedef int VertexType;//顶点类型
//typedef enum GraphKind {DG, DN, UDG, UDN};  //有向图：0，有向网：1，无向图：2，无向

typedef struct ArcNode{	
	int ivex, jvex;//该边所依附的2个顶点的在图中位置
	struct ArcNode *ivexNextarc, *jvexNextarc;//分别指向该边所依附的两个顶点下一条边
}ArcNode;//弧结点信息

typedef struct VNode{
	VertexType data;//顶点信息
	ArcNode *firstedge;//指向第一条依附该顶点的弧的指针
}VNode, AdjMuitiVexList[MAX_VERTEX_NUM];//顶点结点信息

typedef struct{
	AdjMuitiVexList vexs;//顶点向量
	int vexnum, arcnum;//图的当前顶点数和弧数
	//GraphKind kind;//图的种类标志
}AMLGraph;//邻接表表示的图

//若图G中存在顶点v，则返回v在图中的位置信息，否则返回其他信息
int locateVex(AMLGraph G, VertexType v){
	for(int i = 0; i < G.vexnum; i++){
		if(G.vexs[i].data == v)
			return i;
	}
	return -1;//图中没有该顶点
}

//采用邻接多重表表示法构造无向图G
void createUDG(AMLGraph &G){
	printf("输入顶点数和弧数如:(5,3):");
	scanf("%d,%d", &G.vexnum, &G.arcnum);

	//构造顶点向量,并初始化
	printf("输入%d个顶点（以空格隔开如：v1 v2 v3）:", G.vexnum);
	getchar();//吃掉换行符
	for(int m = 0; m < G.vexnum; m++){
		scanf("v%d", &G.vexs[m].data);
		G.vexs[m].firstedge = NULL;//初始化为空指针////////////////重要！！！
		getchar();//吃掉空格符
	}

	//构造邻接多重表
	VertexType v1, v2;//分别是一条的两个顶点
	printf("\n每行输入一条边依附的顶点（如：v1v2）:\n");
	fflush(stdin);//清除残余后，后面再读入时不会出错
	int i = 0, j = 0;
	for(int k = 0; k < G.arcnum; k++){
		scanf("v%dv%d",&v1, &v2);
		fflush(stdin);//清除残余后，后面再读入时不会出错
		i = locateVex(G, v1);//边依附的两个顶点的在图中的位置
		j = locateVex(G, v2);
		
		//采用“头插法”在各个顶点的边链头部插入边结点
		ArcNode *p = (ArcNode *)malloc(sizeof(ArcNode));//构造一个边结点，它依附于vivj两个顶点
		p->ivex = i;
		p->ivexNextarc = G.vexs[i].firstedge;
		G.vexs[i].firstedge = p;
		p->jvex = j;
		p->jvexNextarc = G.vexs[j].firstedge;
		G.vexs[j].firstedge = p;
	}
}

//打印邻接多重表
void printAdjMultiList(AMLGraph G){
	printf("\n");
	for(int i = 0; i < G.vexnum; i++){
		printf("依附顶点v%d的边为：", G.vexs[i].data);
		ArcNode *p = G.vexs[i].firstedge;

		while(p){
			if(p->ivex == i){
				printf("v%dv%d ", G.vexs[i].data, G.vexs[p->jvex].data);
				p = p->ivexNextarc;
			}else if(p->jvex == i){
				printf("v%dv%d ", G.vexs[i].data, G.vexs[p->ivex].data);
				p = p->jvexNextarc;
			}
		}
		printf("\n");
	}
	printf("\n");
}

 

 

 

3.4演示

 

 

/*
测试：
4,3
v1 v2 v3 v4

  v1v2
  v1v3
  v2v4
*/
void main(){
	AMLGraph G;
	createUDG(G);
	printAdjMultiList(G);
}

 

 

 

 

 

4.十字链表

4.1结构定义

十字链表是有向图的另一种链式存储结构。可以理解成有向图的邻接表和逆邻接表的结合，在十字链表中，有两种结点结构：         

             弧结点                                                                                      顶点结点（弧链表表头结点）

          

 

4.2示例

以有向图示例：

4.3代码实现

 

#include<stdio.h>
#include<stdlib.h>
/*
图的表示方法
DG（有向图）或者DN（有向网）：邻接矩阵、邻接表（逆邻接表--为求入度）、十字链表
UDG（无向图）或者UDN（无向网）：邻接矩阵、邻接表、邻接多重表
*/
#define MAX_VERTEX_NUM 10//最大顶点数目
#define NULL 0
//typedef int VRType;//对于带权图或网，则为相应权值
typedef int VertexType;//顶点类型
//typedef enum GraphKind {DG, DN, UDG, UDN};  //有向图：0，有向网：1，无向图：2，无向

typedef struct ArcNode{	
	int tailvex, headvex;//该弧的弧尾（起点）和弧头（终点）所指向的顶点的在图中位置
	struct ArcNode *tailNextarc, *headNextArc;//分别为指向弧尾（起点）相同的弧的下一条弧的指针、弧头（终点）相同的弧的下一条弧的指针
}ArcNode;//弧结点信息

typedef struct VNode{
	VertexType data;//顶点信息
	ArcNode *firstIn;//指向第一条以该顶点为弧尾（起点）的指针
	ArcNode *firstOut;//指向第一条以该顶点的弧头（终点）的指针
}VNode, VexList[MAX_VERTEX_NUM];//顶点结点信息

typedef struct{
	VexList vexs;//顶点向量
	int vexnum, arcnum;//图的当前顶点数和弧数
	//GraphKind kind;//图的种类标志
}OLGraph;//邻接表表示的图

//若图G中存在顶点v，则返回v在图中的位置信息，否则返回其他信息
int locateVex(OLGraph G, VertexType v){
	for(int i = 0; i < G.vexnum; i++){
		if(G.vexs[i].data == v)
			return i;
	}
	return -1;//图中没有该顶点
}

//采用十字链表表示法构造有向图G
void createDG(OLGraph &G){
	printf("输入顶点数和弧数如:(5,3):");
	scanf("%d,%d", &G.vexnum, &G.arcnum);

	//构造顶点向量,并初始化
	printf("输入%d个顶点（以空格隔开如：v1 v2 v3）:", G.vexnum);
	getchar();//吃掉换行符
	for(int m = 0; m < G.vexnum; m++){
		scanf("v%d", &G.vexs[m].data);
		G.vexs[m].firstIn = NULL;//初始化为空指针////////////////重要！！！
		G.vexs[m].firstOut = NULL;
		getchar();//吃掉空格符
	}

	//构造十字链表
	VertexType v1, v2;//分别是一条弧的弧尾和弧头（起点和终点）
	printf("\n每行输入一条弧依附的顶点（先弧尾后弧头）（如：v1v2）:\n");
	fflush(stdin);//清除残余后，后面再读入时不会出错
	int i = 0, j = 0;
	for(int k = 0; k < G.arcnum; k++){
		scanf("v%dv%d",&v1, &v2);
		fflush(stdin);//清除残余后，后面再读入时不会出错
		i = locateVex(G, v1);//弧起点
		j = locateVex(G, v2);//弧终点
		
		//采用“头插法”在各个顶点的弧链头部插入弧结点
		ArcNode *p = (ArcNode *)malloc(sizeof(ArcNode));//构造一个弧结点，作为弧vivj的弧头（终点）
		p->tailvex = i;
		p->tailNextarc = G.vexs[i].firstOut;
		G.vexs[i].firstOut = p;
		p->headvex = j;
		p->headNextArc = G.vexs[j].firstIn;
		G.vexs[j].firstIn = p;
	}
}

//打印十字链表
void printOrthogonalList(OLGraph G){
	printf("\n");
	for(int i = 0; i < G.vexnum; i++){
		printf("以顶点v%d为弧尾的弧有为：", G.vexs[i].data);
		ArcNode *p = G.vexs[i].firstOut;
		while(p){
			printf("v%dv%d ", G.vexs[i].data, G.vexs[p->headvex].data);
			p = p->tailNextarc;
		}
		printf("\n");
	}
	printf("\n");
}

 

4.4演示

 

 

/*测试：
4,7
v1 v2 v3 v4

v1v2
v1v3

v3v1
v3v4

v4v1
v4v2
v4v3
*/
void main(){
	OLGraph G;
	createDG(G);
	printOrthogonalList(G);
}