最小生成树算法

1、普利姆算法

算法思想： 1、从图中找到第一个起始顶点v0，作为最小生成树的第一个顶点，然后从这个顶点到其他顶点中选一条权值最小的边，然后把这条边的顶点vi加入和这条边加入到最小生成树中 2、对剩下顶点顶点，分别检查这些顶点与顶点v的权值是否比这些顶点的lowcost[]中的对应权值小。如果小，则更新lowcost[] 3、从更新的lowcost[]中继续挑选权值最小而且不在生成树中的边，然后加入到生成树中 4、反复执行2、3步骤，知道所有顶点都加入到生成树中。

需要维护两个数组：lowcost[n]，closest[n] lowcost[n]:某个阶段图中顶点的权值 closest[n]：邻接顶点

//采用邻接矩阵
void MST_prime(MGraph G){
    
    int u;
    int min = 65535;//小技巧
    int closest[Maxsize];//保存邻接顶点下标的数组
    int lowcost[Maxsize];//记录当前生成树中到剩余顶点的最小权值
    int closest[0] = 0;//由于刚开始生成树只有一个顶点，不存在边，设为0
    int lowcost[0] = 0;//将0号顶点加入生成树。 等于0表示该号顶点在生成树了
    //初始化数组
    for(int i=1;i<G.vexnum;i++){//除下标为0以外的所有顶点
        lowcost[i] = G.edge[0][i];//将与下标为0的顶点有边的权值存入lowcost数组中
        closest[i] = 0;
    }
    
    //核心算法
    for(int i=1;i<G.vexnum;i++){
        for(int j=1;j<G.vexnum;j++){
            if(lowcost[j]!=0 && lowcost[j]<min){
                min = lowcost[j];
                u = j;
            }
        }
    }
    
    print("打印结点之类的");//按照实际业务来
    lowcost[u] = 0;//将这个顶点加入生成树中
    
    //生成树加入新的顶点后，开始更新lowcost[]的值
    for(int j=0;j<G.vexnum;j++){
        if(lowcost[j]!=0 && G.edge[u][j] < lowcost[j]){
            lowcost[j] = G.edge[u][j];
            closest[j] = u;
        }
            
    }
    
}

算法分析： 双重循环，为O(n的平方)，而且时间复杂度只和n有关，所以适合稠密图

2、克鲁斯卡尔算法

算法思想： 将图中的边按照权值从小到大排列(用到的堆排序)，然后从最小的边开始扫描，设置一个边的集合来记录，如果该边加入不构成回路的话，则将该边加入到当前最小生成中，知道所有的边都检查完。

#define Maxsize 100
typedef struct{
    int a,b;//边的两个顶点
    int weigh;//边的权值
}Edge;//边的结构体

//查找某个集合的根结点
int find(int *parent,int x){
    while(parent[x]>=0){
        x = parent[x];
        return x;
    }
}

//合并两个集合
void union(int *parent,int root1,int root2){
    parent[root2] = root1;
}

Edge edge[Maxsize];
int parent[Maxsize];

void MST_kruskai(MGraph G){
    sort(edge);//按权值大小排列，伪代码
    for(int i=0;i<G.vexnum;i++){
        parent[i] = -1;//初始化，各个顶点单独形成一个集合
    }
    for(int i=0;i<i<G.vexnum;i++){
        n = find(parent,edge[i].a);
        m = find(parent,edge[i].b);
        if(n != m ){
            union(parent,m,n);
            print("%d->%d",edge[i].a,edge[i].b);
        }
    }
}

算法分析： 操作分为对边的权值排序和一个单重循环，他们是并列关系，由于排序耗费时间大于单重循环，所以克鲁斯卡尔算法的主要时间耗费在排序上。排序和图中边的数量有关系，所以适合稀疏图，时间复杂度为O(eloge)。