数据结构(C语言实现)-图(3)(无向图的最小生成树:普里姆算法和克鲁斯卡尔算法)

生成树:在一个连通图G中,取它全部顶点和一部分边构成该图的一个子图G’,若子图的所有边能够使全部顶点连通而不形成任何环,则称子图G’是图G的一个生成树。一个有n个顶点的生成树只有n-1条边。

最小生成树:在一个连通网中,每条边的权值会有不同,各边权值之和最小的生成树成为最小生成树。

构造最小生成树有多种算法,大多数算法利用了最小生成树的MST性质,即:假设**N=(V,{E})**是一个连通网,U是顶点集V的一个非空子集,若(u,v)是一条具有最小权值的边,u∈U,v∈V-U,则必存在一棵包含边(u,v)的最小生成树。
Prim算法和Kruskal算法就是两个利用MST性质构造最小生成树的算法

文章目录

  • Prim(普里姆)算法
  • Kruskal(克鲁斯卡尔)算法

Prim(普里姆)算法

两个集合:顶点集合U,最初只有一个随机取的顶点;边集合TE,最初是个空集。
重复执行下面操作:在所有u∈U,v∈V-U的边(u,v)∈E中,取一条权值最小的边(u0,v0)放入集合TE,同时v0放入集合U。直至U=V。

//图结构使用前面写过的邻接矩阵的代码
//定义一个辅助数组closedge[],数组的每一个元素代表图中一个顶点。每个顶点有两个属性,adjvex代表该顶点与U中哪个元素相连(可以使与之相连的弧的权值最小),lowcost代表与之相连的弧的权值
typedef struct {
	Elemtype adjvex;       //U中元素
	int lowcost;           //权值
}closedge[MAX_VERTEX_NUM];

void MiniSpanTree_Prim(MGraph G,Elemtype u)//从第u个顶点出发构造G的最小生成树
{
	int initVex = LocateVex(&G, u);
	closedge my_closedge;
	for(int i = 0;i<G.vexnum-1;i++)       //辅助数组初始化
		if (i != initVex)
			my_closedge[i] = { u, G.arcs[initVex][i].adj };//与u相连则为权值,不相连则权值为INFINITY
	my_closedge[initVex].lowcost = 0;     //lowcost设为0标志该顶点已经并入U中

	int min = 0;
	for (int i = 1; i < G.vexnum; i++)   //选择其余G.vexnum-1个顶点
	{
		for (int n = 0; n < MAX_VERTEX_NUM - 1; n++)//选出与U中顶点相连的、具有最小权值的顶点
		{
			if (my_closedge[n].lowcost < my_closedge[min].lowcost)
				min = n;                 //序号记在min中
		}
		printf(。。。);//输出生成树的边
		my_closedge[min].lowcost = 0;    //将该顶点并入U集
		for (int n = 0; n < G.vexnum - 1; n++)//新顶点并入U后更新V-U中顶点的权值和顶点信息
			if (G.arcs[min][n].adj < my_closedge[n].lowcost)
				my_closedge[n] = { min,G.arcs[min][n].adj };
	}
}

Kruskal(克鲁斯卡尔)算法

一个非连通图集合T=(V,{}):拥有全部顶点,没有弧,每个顶点自成一个连通分量
重复执行下面操作:在E中选择权值最小的边,若该边依附的两个顶点位于此时T中两个不同的连通分量中,则将此边加入T中,否则舍弃此边而寻找下一条权值最小的边。直至T中只有一个连通分量

//Kruskal算法的图结构借助边集数组实现,边集数组由两个一维数组构成。
//一个一维数组存储顶点信息,另外一个一维结构体数组存储边的信息。
//以下是边集数组的实现
#define MAX_ARCTEX_NUM 20
#define INFINITY 65535
typedef char Elemtype;

typedef struct Edge{
	int head;    //有向图时为弧头指向的顶点序号
	int tail;    //无向图时为弧的两端连接的顶点序号
	int weight;  //权重
}Edge,EdgeVec[MAX_ARCTEX_NUM];

//定义图结构
typedef struct EdgeGraph{
	Elemtype vexs[MAX_VERTEX_NUM];  //顶点数组存储顶点信息
	EdgeVec arcs;                   //弧数组存储弧信息
	int vexnum,arcnum;              //顶点数,弧数
}EdgeGraph;

int LocateVex(EdgeGraph *G,Elemtype info)//确定顶点info在顶点数组中的序号
{
	for(int i = 0; i<G->vexnum; i++)
		if(G->vexs[i] == info)
			return i;
}

void CreateEdgeGraph(EdgeGraph *G)
{
	printf("请输入图的顶点数量和边的数量:");
	scanf_s("%d %d",&(G->vexnum),&(G->arcnum));
	for(int i = 0; i < G->vexnum; i++)
	{
		printf("输入顶点值:");
		scanf_s("%c",&(G->vexs[i]));
	}

	for(int i = 0; i<G->vexnum; i++)  //顶点数组初始化
		G->arcs[i].weight = INFINITY;
	for(int i = 0; i<G->arcnum; i++)  //边集数组赋值
	{
		int weight;
		Elemtype head,tail;
		printf("请输入边的起点终点和权值:");
		scanf_s("%c %c %d",&tail,&head,&weight);
		int v1 = LocateVex(G,tail);
		int v2 = LocateVex(G,head);
		G->arcs[i].weight = weight;
		G->arcs[i].head = v2;
		G->arcs[i].head = v1;
	}
}
//接下来是Kruskal算法的实现
void MiniSpanTree_Kruskal(EdgeGraph *G)
{
	Sort(G);      //对EdgeVec[]即边集数组进行排序,得到权值从小到大的数组
	int *Vexset;  //需要设置一个辅助数组,用于记录各顶点是否在同一个连通分量	
	Vexset = (int*)malloc(sizeof(int)*G.vexnum); //为辅助数组动态分配内存	
	for (i = 0; i < G.vexnum-1; i++)
		Vexset[i] = i;
	int v1,v2,vs1,vs2;
	for(int i = 0; i<G.arcnum-1; i++)
	{
		v1 = LocateVex(&G,EdgeVec[i].head);  //弧连接的顶点的序号
		v2 = LocateVex(&G,EdgeVec[i].tail);
		vs1 = Vexset[v1];                    //顶点所在连通分量的标记
		vs2 = VexSet[v2];
		if(vs1 != vs2)   //弧的两端不在同一连通分量
		{
			printf("%c -> %c \n",EdgeVec[i].head,EdgeVec[i].tail);
			for(int j = 0;j<G.vexnum-1;j++)
			{
				if(Vexset[j] == vs2) //所有和vs2在同一连通分量的顶点加入连通分量vs1
					Vexset[j] = vs1;
			}
		}
	}
}

//快速排序算法,将边集数组按权值大小从新排序
void Sort(EdgeGraph *G)
{
	int min_weight,addr;
	EdgeVec temp;
	for (int i = 0; i < G.arcnum-1; i++)
	{
		min_weight = EdgeVec[i].weight;
		addr = i;
		for (int j = i + 1; j<G.arcnum-1;j++)
		{
			if (min_weight>EdgeVec[j].weight)
			{
				min_weight = EdgeVec[j].weight;
					addr = j;
			}
		}
		if (addr != i)
		{
			temp = EdgeVec[i];
			EdgeVec[i] = EdgeVec[addr];
			EdgeVec[addr] = temp;
		}
	}
}

你可能感兴趣的:(数据结构)