最小生成树(Kruskal实现)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MaxVertexNodeNumSize 1000
#define MaxVertexNodeNameSize 100

struct VertexBodyNode
{
    char VertexName[MaxVertexNodeNameSize];
    int ArcWeight;
    int VertexIndex;
    struct VertexBodyNode *Next;
};

struct VertexHeadNode
{
    char VertexName[MaxVertexNodeNameSize];
    int VertexWeight;
    struct VertexBodyNode *Next;
};

struct _Graph
{
    struct VertexHeadNode VertexHeadNodeList[MaxVertexNodeNumSize];
    int ArcNum,VertexNum;
};

int VertexName2Index(struct _Graph *UnsignedGraph,char *VName)
{
    int i;
    for(i = 0; i < UnsignedGraph -> VertexNum; i ++)
    {
        if(strcmp(UnsignedGraph -> VertexHeadNodeList[i].VertexName,VName)==0)
        {
            return i;
        }
    }
    return -1;
}

void AddOneArc(struct _Graph *UnsignedGraph,int ArcIndex_1,int ArcIndex_2,int AWeight)
{
    struct VertexBodyNode *BNode_1 = malloc(sizeof(struct VertexBodyNode));
    struct VertexBodyNode *BNode_2 = malloc(sizeof(struct VertexBodyNode));

    strcpy(BNode_1 -> VertexName,UnsignedGraph -> VertexHeadNodeList[ArcIndex_1].VertexName);
    strcpy(BNode_2 -> VertexName,UnsignedGraph -> VertexHeadNodeList[ArcIndex_2].VertexName);
    BNode_1 -> ArcWeight = AWeight;
    BNode_2 -> ArcWeight = AWeight;
    BNode_1 -> VertexIndex = ArcIndex_1;
    BNode_2 -> VertexIndex = ArcIndex_2;
    BNode_1 -> Next = BNode_2 -> Next = NULL;

    struct VertexBodyNode *TmpPointer;
    TmpPointer = UnsignedGraph -> VertexHeadNodeList[ArcIndex_1].Next;
    while(TmpPointer != NULL && TmpPointer -> Next != NULL)
    {
        TmpPointer = TmpPointer -> Next;
    }
    if(TmpPointer==NULL)
    {
        UnsignedGraph -> VertexHeadNodeList[ArcIndex_1].Next = BNode_2;
    }
    else
    {
        TmpPointer -> Next = BNode_2;
    }

    TmpPointer = UnsignedGraph -> VertexHeadNodeList[ArcIndex_2].Next;
    while(TmpPointer != NULL && TmpPointer -> Next != NULL)
    {
        TmpPointer = TmpPointer -> Next;
    }
    if(TmpPointer==NULL)
    {
        UnsignedGraph -> VertexHeadNodeList[ArcIndex_2].Next = BNode_1;
    }
    else
    {
        TmpPointer -> Next = BNode_1;
    }
}

void DeleteOneArc(struct _Graph *UnsignedGraph,int ArcIndex_1,int ArcIndex_2)
{
    struct VertexBodyNode *TmpPointer_1,*TmpPointer_2;

    TmpPointer_1 = UnsignedGraph -> VertexHeadNodeList[ArcIndex_1].Next;
    TmpPointer_2 = UnsignedGraph -> VertexHeadNodeList[ArcIndex_1].Next;

    while(TmpPointer_2!=NULL && TmpPointer_2->VertexIndex!=ArcIndex_2)
    {
        TmpPointer_1 = TmpPointer_2;
        TmpPointer_2 = TmpPointer_2 -> Next;
    }

    if(TmpPointer_2==NULL)
    {
        return ;
    }
    else if(TmpPointer_1 == TmpPointer_2)
    {
        UnsignedGraph -> VertexHeadNodeList[ArcIndex_1].Next = NULL;
        free(TmpPointer_2);
    }
    else
    {
        TmpPointer_1 -> Next = TmpPointer_2 -> Next;
        free(TmpPointer_2);
    }

    TmpPointer_1 = UnsignedGraph -> VertexHeadNodeList[ArcIndex_2].Next;
    TmpPointer_2 = UnsignedGraph -> VertexHeadNodeList[ArcIndex_2].Next;

    while(TmpPointer_2!=NULL && TmpPointer_2->VertexIndex!=ArcIndex_1)
    {
        TmpPointer_1 = TmpPointer_2;
        TmpPointer_2 = TmpPointer_2 -> Next;
    }

    if(TmpPointer_2==NULL)
    {
        return ;
    }
    else if(TmpPointer_1 == TmpPointer_2)
    {
        UnsignedGraph -> VertexHeadNodeList[ArcIndex_2].Next = NULL;
        free(TmpPointer_2);
    }
    else
    {
        TmpPointer_1 -> Next = TmpPointer_2 -> Next;
        free(TmpPointer_2);
    }
}

struct _Graph *UGCreat(int ArcSum,int VertexSum)
{
    int i,j;
    struct _Graph *UnsignedGraph = malloc(sizeof(struct _Graph));
    UnsignedGraph -> ArcNum = ArcSum;
    UnsignedGraph -> VertexNum = VertexSum;

    for(i = 0; i < VertexSum; i ++)
    {
        scanf("%s %d",UnsignedGraph -> VertexHeadNodeList[i].VertexName,&UnsignedGraph -> VertexHeadNodeList[i].VertexWeight);
    }

    for(i = 0; i < VertexSum; i ++)
    {
        UnsignedGraph -> VertexHeadNodeList[i].Next = NULL;
    }

    for(i = 0; i < ArcSum; i ++)
    {
        char Arc_1[MaxVertexNodeNameSize];
        char Arc_2[MaxVertexNodeNameSize];
        int ArcIndex_1;
        int ArcIndex_2;
        int ArcWeight;

        scanf("%s %s %d",Arc_1,Arc_2,&ArcWeight);

        ArcIndex_1 = VertexName2Index(UnsignedGraph,Arc_1);
        ArcIndex_2 = VertexName2Index(UnsignedGraph,Arc_2);

        AddOneArc(UnsignedGraph,ArcIndex_1,ArcIndex_2,ArcWeight);
    }
    return UnsignedGraph;
}

void Travel(struct _Graph *UnsignedGraph)
{
    char StartingPoint[MaxVertexNodeNameSize];
    char OverPoint[MaxVertexNodeNameSize];

    printf("Input start and over\n");
    scanf("%s %s",StartingPoint,OverPoint);

    int StartIndex = VertexName2Index(UnsignedGraph,StartingPoint);
    int OverIndex = VertexName2Index(UnsignedGraph,OverPoint);

    struct VertexBodyNode *TmpPointer;
    TmpPointer = UnsignedGraph -> VertexHeadNodeList[StartIndex].Next;
    while(TmpPointer != NULL && TmpPointer -> Next != NULL)
    {
        if(OverIndex==TmpPointer -> VertexIndex)
        {
            printf("Distance:%d GetVertexPointSum:%d",TmpPointer->ArcWeight
                   ,UnsignedGraph -> VertexHeadNodeList[StartIndex].VertexWeight+UnsignedGraph -> VertexHeadNodeList[OverIndex].VertexWeight);
            break;
        }
        else
        {
            TmpPointer = TmpPointer -> Next;
        }
    }
}

struct UnionFindSet
{
    int *ID;
    int *Auxiliary;
    int GroupSum;
    int WeightOriginalTotal;
};

struct UnionFindSet* UnionFindSetInit(int WeightTotal)
{
    struct UnionFindSet *UFSet = malloc(sizeof(struct UnionFindSet));

    UFSet -> GroupSum = WeightTotal;
    UFSet -> WeightOriginalTotal = WeightTotal;

    UFSet -> ID = malloc(WeightTotal*sizeof(int));
    UFSet -> Auxiliary = malloc(WeightTotal*sizeof(int));

    int i;
    for(i = 0; i < WeightTotal; i ++)
    {
        UFSet -> ID[i] = i;
    }
    for(i = 0; i < WeightTotal; i ++)
    {
        UFSet -> Auxiliary[i] = 1;
    }

    return UFSet;
}

int UnionFindSetFind(struct UnionFindSet* UFSet,int WeightNum)
{
    if(WeightNum>UFSet -> WeightOriginalTotal-1 || WeightNum<0)
    {
        return -1;
    }

    while(WeightNum != UFSet -> ID[WeightNum])
    {
        WeightNum = UFSet -> ID[WeightNum];
    }
    return WeightNum;
}

int UnionFindSetUnion(struct UnionFindSet* UFSet,int Weight_1,int Weight_2)
{
    int WeightRoot_1 = UnionFindSetFind(UFSet,Weight_1);
    int WeightRoot_2 = UnionFindSetFind(UFSet,Weight_2);

    if(WeightRoot_1 == -1 || WeightRoot_2 == -1)
    {
        return -1;
    }
    if(WeightRoot_1 == WeightRoot_2)
    {
        return 1;
    }

    if(UFSet -> Auxiliary[WeightRoot_1] < UFSet -> Auxiliary[WeightRoot_2])
    {
        UFSet -> ID[WeightRoot_1] = WeightRoot_2;
        UFSet -> Auxiliary[WeightRoot_2] += UFSet -> Auxiliary[WeightRoot_1];
    }
    else
    {
        UFSet -> ID[WeightRoot_2] = WeightRoot_1;
        UFSet -> Auxiliary[WeightRoot_1] += UFSet -> Auxiliary[WeightRoot_2];
    }

    UFSet -> GroupSum --;
    return 0;
}

bool UnionFindSetIsConnected(struct UnionFindSet* UFSet,int Weight_1,int Weight_2)
{
    return (UnionFindSetFind(UFSet,Weight_1) == UnionFindSetFind(UFSet,Weight_2));
}

struct KruskalElem
{
    int VertexIndex_1;
    int VertexIndex_2;
    int ArcWeight;
};

int CmpStruction(const void *a,const void *b)
{
    struct KruskalElem *c = (struct KruskalElem *)a;
    struct KruskalElem *d = (struct KruskalElem *)b;

    return  c->ArcWeight > d->ArcWeight ? 1 : 0;
}

void KruskalMST(struct _Graph *UnsignedGraph)
{
    struct UnionFindSet *UFSet = UnionFindSetInit(UnsignedGraph->VertexNum);
    struct KruskalElem SortedArcList[2*UnsignedGraph->ArcNum];
    int SortedArcListEnd = 0;
    
    int i;
    for(i = 0; i < UnsignedGraph->VertexNum; i ++)
    {
        struct VertexBodyNode *TmpPointer;
        TmpPointer = UnsignedGraph -> VertexHeadNodeList[i].Next;
        while(TmpPointer != NULL)
        {
            SortedArcList[SortedArcListEnd].VertexIndex_1 = i;
            SortedArcList[SortedArcListEnd].VertexIndex_2 = TmpPointer -> VertexIndex;
            SortedArcList[SortedArcListEnd++].ArcWeight = TmpPointer -> ArcWeight;
            TmpPointer = TmpPointer -> Next;
        }
    }
    
    qsort(SortedArcList,2*UnsignedGraph->ArcNum,sizeof(struct KruskalElem),CmpStruction);
    for(i = 0;i < 2*UnsignedGraph->ArcNum;i ++)
    {
        if(!UnionFindSetIsConnected(UFSet,SortedArcList[i].VertexIndex_1,SortedArcList[i].VertexIndex_2))
        {
            printf("%s ¡ª¡ª%s Distance:%d\n",UnsignedGraph->VertexHeadNodeList[SortedArcList[i].VertexIndex_1].VertexName
                                          ,UnsignedGraph->VertexHeadNodeList[SortedArcList[i].VertexIndex_2].VertexName
                                          ,SortedArcList[i].ArcWeight);
            UnionFindSetUnion(UFSet,SortedArcList[i].VertexIndex_1,SortedArcList[i].VertexIndex_2);
        }
    }
}

int main()
{
    struct _Graph *G = UGCreat(8,5);
    KruskalMST(G);
//    Travel(G);
    return 0;
}

/*
        beijing 18
        zhengzhou 10
        hefei 9
        nanjing 12
        guangzhou 14
        beijing zhengzhou 7
        beijing hefei 9
        beijing nanjing 8
        zhengzhou hefei 5
        hefei nanjing 3
        zhengzhou guangzhou 7
        hefei guangzhou 8
        nanjing guangzhou 6
*/