把构成连通⽹的最⼩代价的⽣成树称为最⼩⽣成树。
连通图：在无向图中，若任意两个顶点vi和vj之间都有路径想通，则称该无向图为连通图。
连通图的生成树：一个连通图的生成树是指一个连通子图，它包含有图中全部n个顶点，但只有足以构成一棵树的n-1条边。一颗有n个顶点的生成树有且仅有n-1条边，如果生成树中再添加一条边，必定成环。
最小生成树：在一给定的无向图G=(V,E)中，(u,v)代表连接顶点u与顶点v的边，而w(u,v)代表边的权重，若存在T为E的子集且为无循环图，使得W(T)最小，则此T为G的最小生成树。把构成连通网的最⼩代价的生成树称为最⼩生成树Minimum Spanning Tree,MST。
最小生成树性质：设G=(V，E)是一个连通网络，T1是顶点集V的一个非空真子集，T2是顶点集V-T1后剩余的子集。若(u，v)是G中一条一个端点在T1中（例如：u∈T1)，另一个端点在T2中的边（例如：v∈T2），且（u，v)具有最小权值，则一定存在G的最小生成树包括此边(u，v)。
我们先把图转换成邻接矩阵，(https://juejin.im/post/5eae34e951882560d56d6588)
利用两个数组来辅助我们记录遍历顶点过程中的数据，两个数组lowcost和arjvex，
- lowcost用于记录当前顶点与所有与它关联顶点间的权重值。下标：顶点下标，值：与当前顶点的权重。
- arjvex用于记录当前顶点与哪个顶点相连接。下标：当前顶点下标，值：与当前顶点相连的前一个顶点。
-
第一次执行image
<figcaption></figcaption>
-
第二次执行image
<figcaption></figcaption>
-
第三次执行image
<figcaption></figcaption>
-
第四次执行image
<figcaption></figcaption>
-
第五次执行image
Prim算法
思路
定义两个数组lowcost和adjvex。其中：
lowcost保存相关顶点间边的权值，lowcost[i]=0代表顶点vi已经加入了最小生成子树中，lowcost[i]=INFINITYC表示i对应的顶点与当前的最小生成树中的顶点暂时不连通，在0<lowcost[i]<INFINITYC的情况中会生成一个与当前最小生成子树的各个顶点之间权值最小的顶点加入到最小生成子树当中。
adjvex保存相关顶点下标 adjvex[i]默认=-1.表示i对应的结点和最小生成子树暂时不连通，adjvex[i] >-1 表示i对应的结点和最小生成树相连的顶点为adjvex[i]
初始化上述数组，默认将v0加入到最小子树中，并更新数组中对应的值
以v0为最小子树，寻找剩余顶点中与v0路径最短的顶点加入v0当中，组成新的最小子树，并更新两个数组的值。
以新的最小子树开始，重复步骤3，直到找到最后一个顶点。
void MiniSpanTree_Prim_1(MGraph G) {
int lowcost[MAXVEX];
int adjvex[MAXVEX];
//初始化两个数组，即默认将v0放入最小生成子树中
adjvex[0] = 0;
lowcost[0] = 0;
int I;
//将v0对应的连通顶点信息存入adjvex，将连通顶点的权值存入lowcost
for(i = 1; i < G.numVertexes; i++) {
if(G.arc[0][i] < INFINITYC) {
adjvex[i] = 0;
}else {
adjvex[i] = -1;
}
lowcost[i] = G.arc[0][I];
}
int k = 0;
int j = 0;
int sum = 0;
for(i = 1; i < G.numVertexes; i++) {
int min = INFINITYC;
//第一次遍历找到lowcost中除去0以外最小的顶点，作为下一个顶点加入最小生成树
for(j = 1; j < G.numVertexes; j++) {
if(lowcost[j] != 0 && lowcost[j] < min) {
min = lowcost[j];
k = j;
}
}
// printf("lowcost为：\n");
// for(int temp = 0; temp < G.numVertexes; temp++) {
// printf("%d ",lowcost[temp]);
// }
// printf("\n");
// printf("adjvex为：\n");
// for(int temp = 0; temp < G.numVertexes; temp++) {
// printf("%d ",adjvex[temp]);
// }
// printf("\n");
/* 打印当前顶点边中权值最小的边 */
printf("(V%d, V%d)=%d\n", adjvex[k], k ,G.arc[adjvex[k]][k]);
sum += G.arc[adjvex[k]][k];
lowcost[k] = 0;
//将与新加入顶点连通的其他顶点加入lowcost中并更新对应的lowcost以及adjvex的值
for(j = 0; j < G.numVertexes; j++) {
if(lowcost[j] != 0 && G.arc[k][j] < lowcost[j]) {
lowcost[j] = G.arc[k][j];
adjvex[j] = k;
}
}
}
printf("sum = %d\n",sum);
}
克鲁斯卡尔算法
思路：
T是边的集合，初始状态为空
将图中的所有边以权值从小到大的顺序进行排序，预定排序后边的起点永远为比较小的顶点
取出权值最小的边，查看它与T中的边是否造成环路，
如果未构成环路，则加入T中；否则，抛弃改边
如果还有剩余边，则返回3中，否则程序结束
证明：
分两步来证明Kruskal算法得到的是最小生成树
Kruskal得到的是一棵生成树
Kruskal得到的生成树代价最小
假设改算法得到的不是生成树，那么有两种情况，第一种是得到的图是有环的，第二种情况是得到的图不连通。由于算法要求，每次加入的边都不能形成环，因此第一种情形不存在。第二种情况，首先我们知道原图是属于连通图，根据算法的要求，取出权值最小的边，如果未构成环路，则加入T中，因为原图是连通的，必然会存在可以连接所有顶点又不构成环路的路径，可以得到Kruskal得到的图肯定也是连通图，因此第二种情况也不存在。
接下来证明Kruskal得到的生成树代价最小。假设图有n个顶点，则生成树一定有n-1条边，最少存在一个最小生成树U。假设：
Kruskal得到的生成树为T。
U和T中不同的边数为k，其他n-1-k条边相同，相同的边构成集合E
在T中而不在U中的边按代价从小到大一次为a1<a2<..<ak
在U中而不在T中的边按代价从小到大一次为x1<x2<..<xk
我们通过把T中的边依次移动到U中来证明U和T是等价的。
首先将a1移动到U中，由于U是一棵生成树，加入一条新边后会行程环路，且这条回路一定会包括x1,x2...,xk中的边，否则a1和E中的边形成环路，则T不是生成树，产生矛盾。
在回路中删除属于x1,x2...,xk且代价最大的边xi构成一棵新的生成树V。
假设a1<xi，则w(V)<w(U)，与最小生成树定义矛盾。
假设a1>xi, 则xi小于a1,a2...,ak，根据Kruskal算法，在考虑最小边的时候会优先考虑xi，而且xi和E也不会构成环路，但是T中并没有xi，说明a1也不会大于xi，即a1 = xi，新得到的w(V)=w(U)。
同理，我们将a2...，ak依次加入到U中，最终得到w(U)=w(T)。证明完毕。
判断是否生成环路
上图中，边(v0,v1)在一条环路中，我们分别从v0和v1开始，因为是环路，我们通过某种规则，最终会达到同样的终点。
判断环路需要一个辅助数组parent[]={0}，存储新加入顶点的路径关系，值为0代表没有新加入的顶点
新增加一个边的结构体来保存每一条边的信息
/* 对边集数组Edge结构的定义 */
typedef struct
{
int begin;
int end;
int weight;
}Edge;
/* 查找连线顶点的尾部下标 */
//根据顶点f以及parent 数组,可以找到当前顶点的尾部下标; 帮助我们判断2点之间是否存在闭环问题;
int Find(int *parent, int f)
{
while ( parent[f] > 0)
{
f = parent[f];
}
return f;
}
/* 交换权值以及头和尾 */
void Swapn(Edge *edges,int i, int j)
{
int tempValue;
//交换edges[i].begin 和 edges[j].begin 的值
tempValue = edges[i].begin;
edges[i].begin = edges[j].begin;
edges[j].begin = tempValue;
//交换edges[i].end 和 edges[j].end 的值
tempValue = edges[i].end;
edges[i].end = edges[j].end;
edges[j].end = tempValue;
//交换edges[i].weight 和 edges[j].weight 的值
tempValue = edges[i].weight;
edges[i].weight = edges[j].weight;
edges[j].weight = tempValue;
}
/* 对权值进行排序 */
void sort(Edge edges[],MGraph *G)
{
//对权值进行排序(从小到大)
int i, j;
for ( i = 0; i < G->numEdges; i++)
{
for ( j = i + 1; j < G->numEdges; j++)
{
if (edges[i].weight > edges[j].weight)
{
Swapn(edges, i, j);
}
}
}
printf("边集数组根据权值排序之后的为:\n");
for (i = 0; i < G->numEdges; i++)
{
printf("(%d, %d) %d\n", edges[i].begin, edges[i].end, edges[i].weight);
}
}
/* 生成最小生成树 */
void MiniSpanTree_Kruskal(MGraph G)
{
int i, j, n, m;
int sum = 0;
int k = 0;
/* 定义一数组用来判断边与边是否形成环路
用来记录顶点间的连接关系. 通过它来防止最小生成树产生闭环;*/
int parent[MAXVEX];
/* 定义边集数组,edge的结构为begin,end,weight,均为整型 */
Edge edges[MAXEDGE];
/*1. 用来构建边集数组*/
for ( i = 0; i < G.numVertexes-1; i++)
{
for (j = i + 1; j < G.numVertexes; j++)
{
//如果当前路径权值 != ∞
if (G.arc[i][j]<INFINITYC)
{
//将路径对应的begin,end,weight 存储到edges 边集数组中.
edges[k].begin = i;
edges[k].end = j;
edges[k].weight = G.arc[i][j];
//边集数组计算器k++;
k++;
}
}
}
//2. 对边集数组排序
sort(edges, &G);
//3.初始化parent 数组为0. 9个顶点;
// for (i = 0; i < G.numVertexes; i++)
for (i = 0; i < MAXVEX; i++)
parent[i] = 0;
//4. 计算最小生成树
printf("打印最小生成树：\n");
/* 循环每一条边 G.numEdges 有15条边*/
for (i = 0; i < G.numEdges; i++)
{
//获取begin,end 在parent 数组中的信息;
//如果n = m ,将begin 和 end 连接,就会产生闭合的环.
n = Find(parent,edges[i].begin);
m = Find(parent,edges[i].end);
//printf("n = %d,m = %d\n",n,m);
/* 假如n与m不等，说明此边没有与现有的生成树形成环路 */
if (n != m)
{
/* 将此边的结尾顶点放入下标为起点的parent中。 */
/* 表示此顶点已经在生成树集合中 */
parent[n] = m;
/*打印最小生成树路径*/
printf("(%d, %d) %d\n", edges[i].begin, edges[i].end, edges[i].weight);
sum += edges[i].weight;
}
}
printf("sum = %d\n",sum);
}
