拓扑排序 C实现

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTEX_NUM 20

typedef struct ArcNode
{
    int data;
    struct ArcNode *next;
}ArcNode, *PArcNode;

typedef struct VNode
{
    int indegree;
    char vertex;
    PArcNode first;
}VNode, AdjList[MAX_VERTEX_NUM];

typedef struct ALGraph
{
    int arcnum, vexnum;
    AdjList adjlist;
}ALGraph, *PALGraph;


int GetLocation(PALGraph palgraph, char v)
{
    for (int i = 0; i < palgraph->vexnum; i++)
    {
        if (v == palgraph->adjlist[i].vertex)
            return i;
    }
    return -1;
}


PALGraph CreateGraph()
{
    PALGraph palgraph = (PALGraph)malloc(sizeof(ALGraph));
    printf("输入定点数和边数:");
    scanf("%d %d", &palgraph->vexnum, &palgraph->arcnum);
    getchar();
    printf("输入每个顶点名称\n");
    for (int i = 0; i < palgraph->vexnum; i++)
    {
        printf("输入第%d个顶点名称：",i);
        scanf("%c", &palgraph->adjlist[i].vertex);
        getchar();
        palgraph->adjlist[i].first = NULL;
        palgraph->adjlist[i].indegree = 0;
    }

    printf("输入边的起始点:\n");
    char u, v;
    int p, q;
    for (int i = 0; i < palgraph->arcnum; i++)
    {
        printf("输入第%d条边起始点:",i);
        scanf("%c %c", &u, &v);
        getchar();
        p = GetLocation(palgraph, u);
        q = GetLocation(palgraph, v);
        if (p != -1 && q != -1)
        {
            if (palgraph->adjlist[p].first == NULL)
            {
                PArcNode parcnode = (PArcNode)malloc(sizeof(ArcNode));
                parcnode->data = q;
                parcnode->next = NULL;
                palgraph->adjlist[p].first = parcnode;
                palgraph->adjlist[q].indegree = palgraph->adjlist[q].indegree + 1;

            }
            else
            {
                PArcNode parcnode = palgraph->adjlist[p].first;
                while (parcnode->next != NULL)
                {
                    parcnode = parcnode->next;
                }
                PArcNode parc = (PArcNode)malloc(sizeof(ArcNode));
                parc->data = q;
                parc->next = NULL;
                parcnode->next = parc;
                palgraph->adjlist[q].indegree += 1;
            }
        }   
    }
    return palgraph;
}


void printALGraph(PALGraph palgraph)
{
    if (palgraph != NULL)
    {
        for (int i = 0; i < palgraph->vexnum; i++)
        {
            printf("%c %d ", palgraph->adjlist[i].vertex, palgraph->adjlist[i].indegree);
            PArcNode p = palgraph->adjlist[i].first;
            while (p != NULL)
            {
                printf("%c ", palgraph->adjlist[p->data].vertex);
                p = p->next;
            }
            printf("\n");
        }
        printf("\n");
    }
    else
    {
        printf("Graph input error!\n");
    }
}


typedef struct SNode
{
    int sdata;
    struct SNode *next;
}SNode, *PSNode;

typedef struct Stack
{
    PSNode top;
    PSNode base;
}Stack,*PStack;

PStack InitStack()
{
    PStack pstack = (PStack)malloc(sizeof(Stack));
    PSNode psnode = (PSNode)malloc(sizeof(SNode));
    psnode->next = NULL;
    pstack->base = psnode;
    pstack->top = psnode;
    return pstack;
}


bool StackEmpty(PStack pstack)
{
    if (pstack->base == pstack->top)
        return true;
    return false;
}


void Push(PStack pstack, int index)
{
    PSNode psnode = (PSNode)malloc(sizeof(SNode));
    psnode->sdata = index;
    psnode->next = pstack->top;
    pstack->top = psnode;
}


int Pop(PStack pstack)
{
    if (!StackEmpty(pstack))
    {
        PSNode psnode = pstack->top;
        pstack->top = psnode->next;
        int data = psnode->sdata;
        free(psnode);
        return data;
    }
    else{
        printf("Stack is Empty!\n");
        return -1;
    }
}


void TopologicalSort(PALGraph palgraph)
{
    int count=0,index;
    PStack pstack = InitStack();
    PArcNode p = NULL;
    for (int i = 0; i < palgraph->vexnum; i++)
    {
        if (palgraph->adjlist[i].indegree == 0)
            Push(pstack, i);
    }

    while (!StackEmpty(pstack))
    {
        index = Pop(pstack);
        printf("%d %c\n", index, palgraph->adjlist[index].vertex);
        count++;
        for (p = palgraph->adjlist[index].first; p != NULL; p = p->next)
        {
            if ((--palgraph->adjlist[p->data].indegree) == 0)
            {
                Push(pstack, p->data);
            }   
        }
    }

    if (count < palgraph->vexnum)
        printf("error!\n");

    printf("\n");
}


int main()
{
    PALGraph palgraph = CreateGraph();
    printALGraph(palgraph);
    TopologicalSort(palgraph);
    return 0;
}