图的更多相关算法-4（拓扑排序）

int TopSort(AGraph *ag, int topsq[])        //此算法是利用堆栈来进行拓扑排序
{
    int loop1 = 0,     node = 0, ivar  = ag->n, count = 0;
    int stack[MAXSIZE],top = -1;
    ArcNode *temp = NULL;

    for(loop1 = 0; loop1 < ivar; ++loop1)           //此循环找到入度为0的点，并把其入栈
    {
        if(ag->adjlist[loop1].indegres == 0)
        {
            ++top;
            stack[top] = loop1;
        }
    }

    while(top > -1)
    {
        node = stack[top];
        --top;                      cout<<"out stack "<<node<<endl;
        topsq[count] = node;                //此处出栈一个入度为0的点，并把其相邻的节点的入度--，
        ++count;
        temp = NULL;
        temp = ag->adjlist[node].firstarc;
        while(temp != NULL)
        {
            --ag->adjlist[temp->adjvex].indegres;
            if(ag->adjlist[temp->adjvex].indegres == 0)         //如果--其相邻的入度后使其入度为0则把它入栈
            {
                ++top;
                stack[top] = temp->adjvex;
            }
            temp = temp->nextarc;
        }
    }
    if(count < ag->n)                                           //count记录了总共有多少个节点符合条件，如果节点数目不与count相同的话，就说明有回路
    {cout<<"find circle"<<endl; return 0;}
    else { cout<<"no circle"<<endl; return 1; }
}

int TopSort2(AGraph *ag, int topsq[])                           //此算法是利用队列取代堆栈
{
    int queue[MAXSIZE], front = -1, rear = -1;
    int ivar = ag->n, loop1 = 0, count = 0, node = 0;
    ArcNode *temp = NULL;

    for(loop1 = 0; loop1 < ivar; ++loop1)
    {
        if(ag->adjlist[loop1].indegres == 0)
        {
            ++rear;
            queue[rear] = loop1;
        }
    }

    while(rear > front)
    {
        ++front;
        node = queue[front];
        topsq[count] = node;
        ++count;
        cout<<"out stack "<<node<<endl;
        temp = NULL;
        temp = ag->adjlist[node].firstarc;
        while(temp != NULL)
        {
            --ag->adjlist[temp->adjvex].indegres;
            if(ag->adjlist[temp->adjvex].indegres == 0)
            {
                ++rear;
                queue[rear] = temp->adjvex;
            }
            temp = temp->nextarc;
        }
    }
    if(count < ag->n)
    {cout<<"find circle"<<endl; return 0;}
    else { cout<<"no circle"<<endl; return 1; }
}

/*
    判断一个图是否存在回路：
    1. 利用拓扑排序
    2. 如图g是有n个节点的无向图，若g的边数e>=n,则一定有回路
    3. 如图是n个节点的无向连通图，如g的每个顶点的度>=2，则图g有回路存在
    4. 利用深度优先遍历可以判断g中是否存在回路
        对于无向图，如遍历的过程中遇到了回边则必定存在环
        对于有向图，这条回边可能是指向深度优先森林中的另一颗生成树上的顶点的弧，但是如果从有向图上的某个顶点v出发
        进行深度优先遍历，若在从此节点的深度优先遍历结束之前出现了一条回边，则图中一定包含环。 因此需要明确从这个顶点的深度遍历是否完成
*/

int visited2 [MAXSIZE];           //visited2[i]  == 0 表示对 i 未被访问过，否则已经访问过
int finished [MAXSIZE];            //finished[i] == 0 表示对顶点 i 的遍历未结束，否则已经结束
int flag = 1;                     //flag == 1 表示AOV网中没有环，为0 表示有环
typedef struct node
{
    int data;
    struct node *next;
}NodeType;

NodeType *head = NULL, *temp = NULL;
void dfs(AGraph *ag, int begin)         //此算法是对有向图进行深度优先遍历
{
    ArcNode  *arctemp  = NULL;
    NodeType *nodetemp = NULL;
    visited2[begin]     = 1;
    finished[begin]    = 0;             //此处赋值为0 表示对begin的节点刚开始遍历，还有访问完成

    arctemp = ag->adjlist[begin].firstarc;
    while(arctemp != NULL)
    {
        if(visited2[arctemp->adjvex] == 1 && finished[arctemp->adjvex] == 0)    //此判断表示遇到的节点已经访问过，并且没有访问完成，则说明遇到了回路
        { flag = 0;}                                //如果finished[i] == 1 则表示对i节点的遍历已经完成此时若是遇到i节点，则表示是图中的森林
        if(visited2[arctemp->adjvex] == 0)                                  //没有访问过，深度访问
        {  dfs(ag, arctemp->adjvex);   finished[arctemp->adjvex] = 1; }     //finished[i] == 1，表示对节点i一经访问完成， 因此设置使finished[i] == 1,应该再dfs遍历节点i之后
        arctemp = arctemp->nextarc;
    }
    //此时应该注意到下面的代码在递归的回溯过程才会执行，因此链表保存的是逆向拓扑排序的顺序节点
    nodetemp = (NodeType *)malloc(sizeof(NodeType));
    nodetemp->data = begin;
    nodetemp->next = NULL;
    if(head == NULL)
    {
        head       = nodetemp;
        temp       = nodetemp;
        temp->next = NULL;
    }else
    {
        temp->next     = nodetemp;
        temp           = nodetemp;
    }
}

void dfs_topsort(AGraph *ag)
{
    int loop1 = 0, ivar = ag->n;

    for(loop1 = 0; loop1 < MAXSIZE; ++loop1)
    {
        visited2[loop1]  = 0;
        finished[loop1] = 0;
    }

    loop1 = 0;
    while(flag == 1 && loop1 < ivar)            //此处为什么要进行循环 dfs 遍历， 因为一个有向无环图中，它的入度为0的点可能不止有一个， 也就是相当于遍历森林
    {
        if(visited2[loop1] == 0)
        {
            dfs(ag,loop1);                      //此函数中当出现环的时候把flag置为0
            finished[loop1] = 1;
        }
        ++loop1;
    }
    if(flag == 1)                              //flag 标志表示图中没有环出项
    {
        cout<<"逆序为："<<endl;
        temp = head;
        while(temp != NULL)
        {
            cout<<temp->data<<' ';
            temp = temp->next;
        }
        cout<<endl;
    }else { cout<<"circle is found"<<endl; }
}



typedef struct line
{
    int begin, end;
    int weight;
}LineType;

void MakeLine(AGraph *ag, LineType lines[])
{
    int loop1 = 0, linenum = 0;
    ArcNode *temp = NULL;

    for(loop1 = 0; loop1 < ag->n; ++loop1)
    {
        temp = ag->adjlist[loop1].firstarc;
        while(temp != NULL)
        {
            lines[linenum].begin  = loop1;
            lines[linenum].end    = temp->adjvex;
            lines[linenum].weight = temp->weight;

            temp                  = temp->nextarc;
            ++linenum;
        }
    }
}

int CriticalPath(AGraph *ag)
{
    int ivar = 0, loop1 = 0;
    int topsq[MAXSIZE], ve[MAXSIZE], vl[MAXSIZE], e[MAXSIZE], l[MAXSIZE];
    ArcNode *temp = NULL;
    LineType lines[MAXSIZE];

    ivar = TopSort(ag,topsq);
    if(ivar == 0)
    { cout<<"this graph has a circle"<<endl; return 0;}

    ivar = ag->n;
    for(loop1 = 0; loop1 < MAXSIZE; ++loop1)
    {
        ve[loop1] = 0;    e[loop1] = 0;
        vl[loop1] = 1000; l[loop1] = 0;
    }

    MakeLine(ag, lines);

    for(loop1 = 0; loop1 < ivar; ++loop1)
    {
        temp = ag->adjlist[loop1].firstarc;
        while(temp != NULL)
        {
            if(ve[temp->adjvex] < ( temp->weight + ve[loop1] ))
                ve[temp->adjvex] = temp->weight + ve[loop1];
            temp = temp->nextarc;
        }
    }

/*
    for(loop1 = 0; loop1 < ivar; ++loop1)
        cout<<ve[loop1]<<' ';
    cout<<endl;
*/

//  cout<<ivar<<endl;
    vl[ivar - 1] = ve[ivar - 1];
    for(loop1 = ivar - 1; loop1 >= 0; --loop1)
    {
        temp = ag->adjlist[loop1].firstarc;
        while(temp != NULL)
        {
            if((vl[temp->adjvex] - temp->weight )< vl[loop1])
                vl[loop1] = vl[temp->adjvex] - temp->weight;
            temp = temp->nextarc;
        }
    }
/*
    for(loop1 = 0; loop1 < ivar; ++loop1)
        cout<<vl[loop1]<<' ';
    cout<<endl;
*/

    for(loop1 = 0; loop1 < ag->e; ++loop1)
    {
        cout<<loop1 <<" line from node  "<<lines[loop1].begin<<" to node "<<lines[loop1].end<<" weight is "<<lines[loop1].weight<<endl;
    }
    for(loop1 = 0; loop1 < ag->e; ++loop1)
    {   e[loop1] = ve[lines[loop1].begin];
        l[loop1] = vl[lines[loop1].end] - lines[loop1].weight;
        cout<<"from node "<<lines[loop1].begin<<" to node "<<lines[loop1].end<<" e is "<<e[loop1]<<"  l is "<<l[loop1]<<endl;
    }

    for(loop1 = 0; loop1 < ag->e; ++loop1)
        if(e[loop1] == l[loop1])
            cout<<loop1<<' ';

    cout<<endl;

    return 1;
}