最小生成树--Prime&Kruskal

还是老样子，先上图，说明思想和过程再上代码详细的分步解释

算法图解

对于最小生成树相信大家在上过数据结构以后都有所耳闻，最小生成树的概念在此就不再重复性的阐述了。对于最小生成树常用的算法有prime算法和kruskal算法。

prime算法比较适用于稠密图

kruskal算法比较适用于稀疏图

具体原因将会在放核心算法的代码片时进行分析说明

先来看看一张随便画出来的图片吧:

Prime构建最小生成树的过程为 : 1–>2，2–>3，2–>5，1–>4，4–>5

Kruskal构建最小生成树的过程为:4–>6，2–>3，2–>5，1–>2，1–>4

现在来说明一下为什么这样以及算法思想的概括

Prime

Prime算法的思想是从任意一个顶点出发然后去找到达的点，Prime算法也可以理解为是一种贪心的过程，不断找每次的最优(在不构成回路的前提下)，每次的最优从而遍历到每一个顶点连接起来的图，就是最小生成树。

Kruskal

Kruskal算法的思想是从边开始遍历，将边从小到大进行一次排列不断选最小的，再找其相连节点，Kruskal算法的过程和并查集有些类似，可以通过并查集进行查找，利用并查集的路径压缩做简单的优化调整。

算法核心代码

Prime

结构体声明

/**
 * 结构体声明
 * 将图用邻接矩阵的方式存起来
 */
struct MGraph{
	int arc[100][100];
	int numVertexes; //图中顶点的个数
}G;

初始化

void init(MGraph *G,int vertex,int side){
	int i ,j,temp;
	int vertex1,vertex2,distance;
	i = j = 0;
	G->numVertexes = vertex;
	for(i = 0;i<G->numVertexes;i++){
		for(j = 0;j<G->numVertexes;j++){
			if(i==j){
				G->arc[i][j] = 0;//自己到自己的距离为0
			}
			else{
				G->arc[j][i] = INFINITY;//INFINITY表示不可达
			}
		}
	}
	printf("请输入顶点a到顶点b以及距离c 如: 1 2 3 \n");
	printf("表示 顶点 1 到 顶点 2 有一条距离为 3 的边\n");
	for(i = 0;i<side;i++){
		scanf("%d %d %d",&vertex1,&vertex2,&distance);
		G->arc[vertex1-1][vertex2-1] = G->arc[vertex2-1][vertex1-1] = distance;
	}
	
	printf("\n您输入的矩阵为:\n");
	for(i = 0;i<G->numVertexes;i++){
		for(j = 0;j<G->numVertexes;j++){
			if(G->arc[i][j]==INFINITY){
				printf("∞ ");
			}
			else{
				printf("%d ",G->arc[i][j]);
			}
		}
		printf("\t\n");
	}
	printf("\n");
}

核心代码

void MiniSpanTree_Prim(MGraph G){
	printf("Prim算法的建树过程为:\n");
	int min,i,j,k;
	int adjvex[G.numVertexes];//保存顶点的下标
	int lowcost[G.numVertexes];//保存边的权值
	lowcost[0] = 0;//初始化第一个权值为0，第一个顶点加入生成树
	/*补充说明，lowcost的值为0就表示了该点已经加入了生成树之中*/
	adjvex[0] = 0;//初始化第一个顶点下标
/**
 * 遍历其他的顶点
 */
	for(i = 1;i<G.numVertexes;i++){
		lowcost[i] = G.arc[0][i];
		adjvex[i] = 0;
	}
	for(i = 1;i<G.numVertexes;i++){
		min = INFINITY;//初始化最小权值，后面不断寻找最优
		j = 1;k = 0;
		while(j<G.numVertexes){//循环遍历所有顶点
			if(lowcost[j]!=0&&lowcost[j]<min){//找到最小的边的权值
				min = lowcost[j];
				k = j;
			}
			j++;
		}
		printf("(%d,%d)\n",adjvex[k]+1,k+1);
		lowcost[k] = 0;
		for(j = 1;j<G.numVertexes;j++){
			if(lowcost[j]!=0&&G.arc[k][j]<lowcost[j]){
				/*如果下标为k的顶点的各边权值
				小于其他各个未加入生成树顶点的权值
				（这句话比较绕不知道表述对了没,语文不好）*/
				lowcost[j] = G.arc[k][j];//就将其加入最小生成树中
				adjvex[j] = k;
			}
		}
	}
}

Prime算法的介绍暂时告一段落，下面继续介绍Kruskal

Kruskal算法中会用到一些并查集相关的知识如果对并查集不太了解请先移步至并查集。这是让我看懂了并查集的一篇文章很有趣且详细。

下面开始上Kruskal的代码

Kruskal

int n,m,tot=0,k=0;//n端点总数，m边数，tot记录最终答案，k已经连接了多少边 
int fat[200010];//记录集体老大 
struct node
{
	int from,to,dis;//结构体储存边 
}edge[200010];
bool cmp(const node &a,const node &b)//sort排序（当然你也可以快排） 
{
	return a.dis<b.dis;
}
int father(int x)//找集体老大，并查集的一部分 
{
	if(fat[x]!=x)
	return father(fat[x]);
	else return x;
}
void unionn(int x,int y)//加入团体，并查集的一部分 
{
	fat[father(y)]=father(x);
}
int main()
{
	scanf("%d%d",&n,&m);//输入点数，边数 
	for(int i=1;i<=m;i++)
	{
		/*输入边的信息 */
		scanf("%d%d%d",&edge[i].from,&edge[i].to,&edge[i].dis);	
	}
	for(int i=1;i<=n;i++) fat[i]=i;//自己最开始就是自己的老大 （初始化） 
	sort(edge+1,edge+1+m,cmp);//按权值排序（kruskal的体现） 
	for(int i=1;i<=m;i++)//从小到大遍历 
	{
		if(k==n-1) break;//n个点需要n-1条边连接 
		if(father(edge[i].from)!=father(edge[i].to))//假如不在一个团体 
		{
			unionn(edge[i].from,edge[i].to);//加入 
			tot+=edge[i].dis;//记录边权 
			k++;//已连接边数+1 
		}
	}
	printf("%d",tot);
	return 0;
}

过程思想借助了《大话数据结构》一书