最小生成树（Kruskal算法）

• Kruskal算法思想
  Kruskal算法采用以边为目标进行构建，因为权值在边上，所以直接根据最小权值的边进行构建生成树也是很自然的想法，只不过需要检测构建生成树时候产生环路。检测环路根据并查集的思想，通过判断被考察的边的两个顶点是否位于两个连通分量中，我们把连通分量看成树，通过判断两颗树是否有不同的根结点，如果是不同的根结点，那么不会产生环，进行合并，如果具有相同的根结点，那么产生环，则放弃该边，继续探索下一个更小权值的边。

#include <iostream>
#include <string>
#include <vector>
using namespace std;

#define MaxSize 10
#define INF 99999

typedef struct EdgeType{
    int from,to; //边依附的两个顶点
    int weight;
}EdgeType;

//图采用边集数组
typedef struct EdgeGraph{
    char vertype[MaxSize];
    EdgeType Edges[MaxSize];
    int n;
    int e;
}EdgeGraph;

typedef struct{
    char data;
}VerNode;

typedef struct{
    int edges[MaxSize][MaxSize];
    VerNode VerType[MaxSize];
    int n;
    int e;
}MGraph;

void InitMGraph(MGraph* G){
    G->e = 9;
    G->n = 6;
    for (int i = 0; i < G->n; i++) {
        for (int j = 0; j < G->n; j++) {
            G->edges[i][j] = INF;
        }
    }
    G->edges[0][1] = 34;  G->edges[1][0] = 34;
    G->edges[0][2] = 46;  G->edges[2][0] = 46;
    G->edges[0][5] = 19;  G->edges[5][0] = 19;
    G->edges[1][4] = 12;  G->edges[4][1] = 12;
    G->edges[2][3] = 17;  G->edges[3][2] = 17;
    G->edges[2][5] = 25;  G->edges[5][2] = 25;
    G->edges[3][5] = 25;  G->edges[5][3] = 25;
    G->edges[3][4] = 38;  G->edges[4][3] = 38;
    G->edges[4][5] = 26;  G->edges[5][4] = 26;
}

//将邻接矩阵转换成边集数组
void TransToEdge(MGraph* G,EdgeGraph* &E){
    E->e = G->e;
    E->n = G->n;
    for (int i = 0,k = 0; i < G->n; i++) {
        for (int j = i + 1; j < G->n; j++) {
            if (G->edges[i][j]!=INF) {
                E->Edges[k].from = i;
                E->Edges[k].to = j;
                E->Edges[k].weight =  G->edges[i][j];
                k++;
            }
        }
    }
    for (int i = 0; i< G->e; i++) {
        for (int j = i + 1; j < G->e; j++) {
            if (E->Edges[i].weight>E->Edges[j].weight) {
                EdgeType temp = E->Edges[i];
                E->Edges[i] = E->Edges[j];
                E->Edges[j] = temp;
            }
        }
    }
//    for (int i = 0; i<G->e; i++) {
//        cout<<"Edges:"<<E->Edges[i].from<<" "<<E->Edges[i].to<<" "<<E->Edges[i].weight<<endl;
//    }
}

//并查集思想，查找双亲结点
int FindRoot(int* parent,int v){
    int t = v;
    //找双亲结点
    while (parent[t] > -1) {
        t = parent[t];
    }
    return t;
}

void Krusual(EdgeGraph* G){
    int num = 0;
    int parent[MaxSize];
    for (int i = 0; i< G->n; i++) {
        parent[i] = -1;
    }
    
    //遍历的是边的个数
    for (int j = 0; j < G->e; j++) {
        int vexPre = FindRoot(parent,G->Edges[j].from);
        int vexBack = FindRoot(parent,G->Edges[j].to);
        if (vexPre != vexBack) {
            cout<<endl<<"("<<G->Edges[j].from<<","<<G->Edges[j].to<<")"<<endl;
            //Union
            parent[vexPre] = vexBack;
            num++;
            if (num == G->n - 1) {
                return;
            }
        }
    }
    
}

int main(int argc, const char * argv[]) {
    MGraph* G = new MGraph();
    EdgeGraph* E = new EdgeGraph();
    InitMGraph(G);
    TransToEdge(G, E);
    Krusual(E);
    return 0;
}