Kruskal算法构造最小生成树

/*********************************************************
* Name: Kruskal算法构造最小生成树
* Date: 2022.01.26
* Author: 吕辉
* Description: 给定无向网，通过Kruskal算法构造出最小生成树。
*              最小生成树采用类似并查集存储结构。
*********************************************************/
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

typedef struct
{
    char data;
    int  parent;
    int weight;
}MFSetNode;/*并查集结点*/

typedef struct
{
    int vexnum;
    MFSetNode* head;
}MFSet;/*并查集*/

typedef struct
{
    char vex1;
    char vex2;
    int weight;
}ArcNode;/*边结点*/

typedef struct
{
    int arcnum;
    ArcNode* head;
}Arc;/*边表*/

void Kruskal(Arc* E, MFSet* T);
/*并查集相关函数*/
void InitMFSet(MFSet* T);
int FindMFSet(MFSet* T, int vex);
void UnionMFSet(MFSet* T, int vex1, int vex2, int weight);
void InversionMFSet(MFSet* T, int vex);
void PrintMFSet(MFSet T);
/*边表相关函数*/
void InitArc(Arc* E);
void BubbleSortArc(Arc* E);
int LocateVex(MFSet* T, char vexdata);

int main(void)
{
    Arc E;/*边表*/
    MFSet T;/*并查集树*/
    printf("请输入顶点数和边数(逗号分隔)：");
    scanf("%d%*c%d", &T.vexnum, &E.arcnum);
    Kruskal(&E, &T);
    PrintMFSet(T);
    system("pause");
    return 0;
}
/***********************************************
* Name: Kruskal
* Parameter: E 边表, T 并查集
* Call: InitMFSet, InitArc, BubbleSortArc,
*          FindMFSet, UnionMFSet.
* Called By: main
* Description: 第一步：按权值从小到大排序边表；
*              第二步：选择不会产生环路的边；
*              第三步：将其加入最小生成树中。
************************************************/
void Kruskal(Arc* E, MFSet* T)
{
    int i = 0;
    int e = 0;
    int vex1 = 0;
    int vex2 = 0;
    int root1 = 0;
    int root2 = 0;
    int weight = 0;

    InitMFSet(T);
    InitArc(E);
    BubbleSortArc(E);
    while (e < T->vexnum - 1)
    {
        /*字符型元素转换为并查集中对应元素下标*/
        weight = E->head[i].weight;
        vex1 = LocateVex(T, E->head[i].vex1);
        vex2 = LocateVex(T, E->head[i].vex2);
        root1 = FindMFSet(T, vex1);
        root2 = FindMFSet(T, vex2);
        if (root1 != root2)/*vex1和vex2不在一棵树中*/
        {
            UnionMFSet(T, vex1, vex2, weight);
            e++;
        }
        i++;
    }
}
/*************************************************
* Name: InitMFSet
* Parameter: T 并查集
* Called By: Kruskal
* Description: 初始化并查集。
**************************************************/
void InitMFSet(MFSet* T)
{
    int i = 0;
    T->head = (MFSetNode*)calloc(T->vexnum, sizeof(MFSetNode));
    for (i = 0; i < T->vexnum; i++)
    {
        printf("请输入第%d个顶点：", i + 1);
        scanf(" %c", &T->head[i].data);
        /*每个元素自成一棵树*/
        /*令每棵树根结点的parent域存储该棵树中结点的个数*/
        /*为避免混淆，根结点的parent域规定为负值*/
        T->head[i].parent = -1;
    }
}
/***************************************************
* Name: FindMFSet
* Parameter: T 并查集
* Called By: Kruskal, UnionMFSet, InversionMFSet.
* Return: 查找并返回vex所在树的根结点。
****************************************************/
int FindMFSet(MFSet* T, int vex)
{
    int i = vex;
    while (T->head[i].parent > -1)    /*找根*/
    {
        i = T->head[i].parent;
    }
    return i;
    /*不能压缩路径，因为会破坏最小生成树的层次结构*/
}
/*********************************************************
* Name: UnionMFSet
* Parameter: T 并查集, vex1 顶点1,vex2 顶点2, 
*            weight 顶点vex1和vex2所在弧的权值
* Called By: Kruskal
* Description: 合并两棵树，并加入对应边的权值。
**********************************************************/
void UnionMFSet(MFSet* T, int vex1, int vex2, int weight)
{
    int root1 = FindMFSet(T, vex1);
    int root2 = FindMFSet(T, vex2);
    if (T->head[root1].parent > T->head[root2].parent)/*树root1含元素比root2少， 注意根结点parent域是以负值存储的树中结点数量*/
    {
        if (T->head[vex1].parent > -1)
        {
            InversionMFSet(T, vex1);/*以当前结点为根，逆置当前结点所在树*/
        }
        T->head[root2].parent += T->head[vex1].parent;
        T->head[vex1].parent = vex2;
        T->head[vex1].weight = weight;
    }
    else
    {
        if (T->head[vex2].parent > -1)
        {
            InversionMFSet(T, vex2);/*以当前结点为根，逆置当前结点所在树*/
        }
        T->head[root1].parent += T->head[vex2].parent;
        T->head[vex2].parent = vex1;
        T->head[vex2].weight = weight;
    }
}
/******************************************************
* Name: InversionMFSet
* Parameter: T 并查集, vex 顶点
* Called By: UnionMFSet
* Description: 以vex为根节点旋转vex所在的并查集树。
*******************************************************/
void InversionMFSet(MFSet* T, int vex)
{
    int i = T->head[vex].parent;
    int j = vex;
    int weight = T->head[vex].weight;

    /*设置当前结点为根结点*/
    T->head[vex].parent = T->head[FindMFSet(T, vex)].parent;
    /*依次设置当前结点的双亲结点指向当前结点*/
    while (T->head[i].parent > -1)
    {
        i = T->head[i].parent;
        T->head[i].parent = j;
        j = i;
    }
    T->head[i].parent = j;/*原来的根结点也要补上*/
    T->head[i].weight = T->head[j].weight;
}
/*************************************************
* Name: PrintMFSet
* Parameter: T 并查集
* Called By: main
* Description: 打印并查集树。
**************************************************/
void PrintMFSet(MFSet T)
{
    int i = 0;
    printf("最小生成树(双亲表示法)：\n-----------------------------------\n");
    printf("num\tvex\tparent\tweight\n");
    for (i = 0; i < T.vexnum; i++)
    {
        printf("%d\t%c\t%3d\t%3d\n", i, T.head[i].data, T.head[i].parent, T.head[i].weight);
    }
    printf("-----------------------------------\n");
}
/*************************************************
* Name: InitArc
* Parameter: E 边表
* Called By: Kruskal
* Description: 初始化边表。
**************************************************/
void InitArc(Arc* E)
{
    int i = 0;
    E->head = (ArcNode*)calloc(E->arcnum, sizeof(ArcNode));
    for (i = 0; i < E->arcnum; i++)
    {
        printf("请输入第%d条边的两端点和权值(逗号分隔)：", i + 1);
        scanf(" %c%*c%c%*c%d", &E->head[i].vex1, &E->head[i].vex2, &E->head[i].weight);
    }
}
/*************************************************
* Name: BubbleSortArc
* Parameter: E 边表
* Called By: Kruskal
* Description: 冒泡排序法按升序排序边表E。
**************************************************/
void BubbleSortArc(Arc* E)
{
    int i = 0;
    int j = 0;
    ArcNode t;
    for (i = 1; i <= E->arcnum - 1; i++)
    {
        for (j = 0; j < E->arcnum - i; j++)
        {
            if (E->head[j].weight > E->head[j + 1].weight)
            {
                t = E->head[j];
                E->head[j] = E->head[j + 1];
                E->head[j + 1] = t;
            }
        }
    }
}
/****************************************
* Name: LocateVex
* Parameter: T 并查集, vexdata 顶点
* Called By: Kruskal
* Return: 查找并返回vex在并查集中的位置；
*         若不存在该顶点返回-1。
****************************************/
int LocateVex(MFSet* T, char vexdata)
{
    int i = 0;
    for (i = 0; i < T->vexnum; i++)
    {
        if (T->head[i].data == vexdata)
        {
            return i;
        }
    }
    return -1;
}