【拓扑序列】-求邻接表储存的有向图的拓扑序列

#include <iostream>
#include <stack>
using namespace std;

typedef struct ArcNode
{
    int adjvex;
    struct ArcNode *nextarc;
} ArcNode;

typedef struct VNode
{
    int data;
    ArcNode *firstarc;
} VNode,AdjList[100];

typedef struct
{
    AdjList vertices;
    int vexnum,arcnum;
} ALGraph;

int LocateVex(ALGraph G,int v)
{
    int i;
    for(i=0; i<G.vexnum; i++)
        if(G.vertices[i].data==v)
            return i;
    return -1;
}

void CreateALGraph(ALGraph &G)
{
    int i,j,k,v1,v2;
    cin>>G.vexnum>>G.arcnum;
    for(i=0; i<G.vexnum; i++)
    {
        cin>>G.vertices[i].data;
        G.vertices[i].firstarc=NULL;
    }
    for(k=0; k<G.arcnum; k++)
    {
        cin>>v1>>v2;
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);
        ArcNode *p1=new ArcNode;
        p1->adjvex=j;
        p1->nextarc=G.vertices[i].firstarc;
        G.vertices[i].firstarc=p1;
    }
}

void InDegree(ALGraph &G, int indegree[])
{
    for(int k=0; k<G.vexnum; k++)
    {
        int i = LocateVex(G, G.vertices[k].data);
        int n = 0;
        ArcNode *p=new ArcNode;
        for (int j = 0; j <G.vexnum; j++)
        {
            if (j == i)
            {
                continue;
            }
            for (p = G.vertices[j].firstarc; p; p = p->nextarc)
            {
                if (p->adjvex == i)
                {
                    n++;
                    break;
                }

            }
        }
        cout<<"v"<<G.vertices[k].data<<":"<<n<<"\n";
        indegree[k]=n;
    }
}

void TopologicalSort(ALGraph G,int topo[])
{
    int i,k,m;
    int indegree[G.vexnum];
    InDegree(G,indegree);
    stack<int> S;
    for(i=0; i<G.vexnum; i++)
        if(!indegree[i])//入度为0的顶点进栈
            S.push(i);
    m=0;
    while(!S.empty())
    {
        i=S.top();
        S.pop();
        topo[m]=i;
        m++;
        ArcNode *p=G.vertices[i].firstarc;
        while(p!=NULL)
        {
            k=p->adjvex;
            indegree[k]--;
            if(indegree[k]==0)
                S.push(k);
            p=p->nextarc;
        }
    }
    if(m<G.vexnum)
        cout<<"ERRO";
}
int main()
{
    int topo[100];
    ALGraph G;
    CreateALGraph(G);
    TopologicalSort(G,topo);
    for(int i=0;i<G.vexnum;i++)
        cout<<"v"<<G.vertices[topo[i]].data<<' ';
    return 0;
}
//小绵杨Yeanling