拓扑排序(Kahn实现)

#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;
};

typedef int ElementType;

struct StackNode
{
    ElementType Element;
    struct StackNode *Next;
};

int StackIsEmpty(struct StackNode *StackTop)
{
    return (StackTop -> Next == NULL);
}

int StackPush(ElementType ToBePush,struct StackNode *StackTop)
{
    struct StackNode *TmpCell;

    TmpCell = malloc(sizeof(struct StackNode));
    if(TmpCell == NULL)
    {
        return 1;
    }
    else
    {
        TmpCell -> Element = ToBePush;
        TmpCell -> Next = StackTop -> Next;
        StackTop -> Next = TmpCell;
    }
    return 0;
}

ElementType StackGetTop(struct StackNode *StackTop)
{
    if(!StackIsEmpty(StackTop))
    {
        return StackTop -> Next -> Element;
    }
}

int StackPop(struct StackNode *StackTop)
{
    struct StackNode *FirstCell;

    if(StackIsEmpty(StackTop))
    {
        return 1;
    }
    else
    {
        FirstCell = StackTop -> Next;
        StackTop -> Next = StackTop -> Next -> Next;
        free(FirstCell);
    }
    return 0;
}

int MakeStackEmpty(struct StackNode *StackTop)
{
    if(StackTop == NULL)
    {
        return 1;
    }
    else
    {
        while( !StackIsEmpty(StackTop) )
        {
            StackPop(StackTop);
        }
    }
    return 0;
}

struct StackNode *StackInit()
{
    struct StackNode *StackTop;

    StackTop = malloc(sizeof(struct StackNode));
    if(StackTop == NULL)
    {
        return NULL;
    }

    StackTop -> Next = NULL;
    MakeStackEmpty(StackTop);
    return StackTop;
}

int StackDelete(struct StackNode *StackTop)
{
    if(StackTop == NULL)
    {
        return 1;
    }
    else
    {
        MakeStackEmpty(StackTop);
        free(StackTop);
    }
    return 0;
}

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

void AddOneArc(struct _Graph *DirectedGraph,int ArcIndex_1,int ArcIndex_2,int AWeight)
{
    struct VertexBodyNode *BNode = malloc(sizeof(struct VertexBodyNode));

    strcpy(BNode -> VertexName,DirectedGraph -> VertexHeadNodeList[ArcIndex_2].VertexName);

    BNode -> ArcWeight = AWeight;
    BNode -> VertexIndex = ArcIndex_2;
    BNode -> Next = NULL;

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

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

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

    for(i = 0; i < VertexSum; i ++)
    {
        DirectedGraph -> 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(DirectedGraph,Arc_1);
        ArcIndex_2 = VertexName2Index(DirectedGraph,Arc_2);

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

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

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

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

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

bool KahnTopologicalSort(struct _Graph *DirectedGraph)
{
    int InDgree[DirectedGraph->VertexNum];
    memset(InDgree,0,sizeof(InDgree));


    // count every vertex's indgree and store in array InDgree
    int i;
    struct VertexBodyNode *TmpPointer;
    for(i = 0; i < DirectedGraph->VertexNum; i ++)
    {
        TmpPointer = DirectedGraph->VertexHeadNodeList[i].Next;
        while(TmpPointer != NULL)
        {
            InDgree[TmpPointer->VertexIndex] ++;
            TmpPointer = TmpPointer -> Next;
        }
    }
    
    //put Vertex whose Indgree is zero into stack
    struct StackNode *StackTop;
    StackTop = StackInit();
    for(i = 0; i < DirectedGraph->VertexNum; i ++)
    {
        if(!InDgree[i])
        {
            StackPush(i,StackTop);
        }
    }
    
    int Index;
    while(!StackIsEmpty(StackTop))
    {
        Index = StackGetTop(StackTop);
        StackPop(StackTop);
        printf("%s ",DirectedGraph -> VertexHeadNodeList[Index].VertexName);
        
        TmpPointer = DirectedGraph->VertexHeadNodeList[Index].Next;
        while(TmpPointer != NULL)
        {
            InDgree[TmpPointer->VertexIndex] --;
            if(! InDgree[TmpPointer->VertexIndex])
            {
                StackPush(TmpPointer->VertexIndex,StackTop);
            }
            TmpPointer = TmpPointer -> Next;
        }
    }
}

int main()
{
    struct _Graph *G = UGCreat(8,5);

//    Travel(G);
    KahnTopologicalSort(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
        
*/