华农专业课拯救计划：拓扑排序

1.整体复制问题，让你更快的找到我

【问题描述】

由某个集合上的一个偏序得到该集合上的一个全序，这个操作被称为拓扑排序。偏序和全序的定义分别如下：若集合X上的关系R是自反的、反对称的和传递的，则称R是集合X上的偏序关系。设R是集合X上的偏序，如果对每个x,y∈X必有xRy或yRx，则称R是集合X上的全序关系。由偏序定义得到拓扑有序的操作便是拓扑排序。

拓扑排序的流程如下：

1. 在有向图中选一个没有前驱的顶点并且输出之；

2. 从图中删除该顶点和所有以它为尾的弧。

重复上述两步，直至全部顶点均已输出，或者当前图中不存在无前驱的顶点为止。后一种情况则说明有向图中存在环。

采用邻接表存储有向图，并通过栈来暂存所有入度为零的顶点，可以描述拓扑排序的算法如下：

在本题中，读入一个有向图的邻接矩阵（即数组表示），建立有向图并按照以上描述中的算法判断此图是否有回路，如果没有回路则输出拓扑有序的顶点序列。

【输入形式】

输入的第一行包含一个正整数n，表示图中共有n个顶点。其中n不超过50。

以后的n行中每行有n个用空格隔开的整数0或1，对于第i行的第j个整数，如果为1，则表示第i个顶点有指向第j个顶点的有向边，0表示没有i指向j的有向边。当i和j相等的时候，保证对应的整数为0。

【输出形式】

如果读入的有向图含有回路，请输出“ERROR”，不包括引号。

如果读入的有向图不含有回路，请按照题目描述中的算法依次输出图的拓扑有序序列，每个整数后输出一个空格。

请注意行尾输出换行。

【样例输入】

4
0 1 0 0
0 0 1 0
0 0 0 0
0 0 1 0
【样例输出】

3 0 1 2

【说明】请注意采用邻接表存储结构时，链表创建需采用尾插法，以保证后续结点从小到大排列。

在本题中，需要严格的按照题目描述中的算法进行拓扑排序，并在排序的过程中将顶点依次储存下来，直到最终能够判定有向图中不包含回路之后，才能够进行输出。

另外，为了避免重复检测入度为零的顶点，可以通过一个栈结构维护当前处理过程中入度为零的顶点。

2.不废话，先复制代码

#include<iostream>
#include<stack>
using namespace std;
const int size1 = 50;
typedef struct point
{
    int data;
    point* next;
}node;
typedef struct grap
{
    int in;
    int data;
    int flag;
    node* edge;
}grape;
grape G[size1];
int res[size1];
void tobu(int limit)
{
    stack <grape*>s;
    int count = 0;
    for (int i = 0; i < limit; i++)
    {
        if (G[i].in == 0)
        {
            s.push(&G[i]);
            G[i].flag = 0;
        }
    }
    while (!s.empty())
    {
        grape* pos = s.top();
        s.pop();
        count++;
        res[count] = pos->data;
        node* p = pos->edge;
        while (p != NULL)
        {
            int num = p->data;
            G[num].in--;
            p = p->next;
        }
        for (int i = 0; i < limit; i++)
        {
            if (G[i].in == 0 && G[i].flag == 1)
            {
                s.push(&G[i]);
                G[i].flag = 0;
            }
        }
    }
    if (count == limit)
    {
        for (int i = 1; i <= limit; i++)
        {
            cout << res[i] << " ";
        }
    }
    else
    {
        cout << "ERROR";
    }
}
int main()
{
    int num;
    cin >> num;
    for (int i = 0; i < num; i++)
    {
        G[i].in = 0;
        G[i].data = i;
        G[i].edge = NULL;
        G[i].flag = 1;
    }
    for (int i = 0; i < num; i++)
    {
        for (int j = 0; j < num; j++)
        {
            int num1;
            cin >> num1;
            if (num1 == 0)
            {
                continue;
            }
            else
            {
                node* temp = new node;
                temp->data = j;
                temp->next = NULL;
                node* pos = G[i].edge;
                while (1)
                {
                    if (pos == NULL) break;
                    if (pos->next == NULL) break;
                    else
                        pos = pos->next;
                }
                if (pos == NULL)
                {
                    G[i].edge = temp;
                }
                else
                {
                    pos->next = temp;
                }
                G[j].in++;
            }
        }
    }
   tobu(num);
    return 0;
}

3.简单聊聊思想

首先谈一谈变量的意义，node代表着邻接表的后续边，分为顶点数据和下一个顶点的索引，结构体grape代表邻接矩阵的顶点，有入度，数据，是否可以继续访问的标识flag，以及下一条边的索引，edge，G是邻接表顶点的集合，res存储着拓扑排序的结果，以下是拓扑排序主体函数的解析，定义一个栈，定义一个变量count用于记录res数组中顶点的数量，然后遍历邻接表的顶点，如果顶点入度为0，也就是起点，就压入栈中，并将该顶点的flag改为不可访问状态，当栈不空时，进行出栈操作，将栈顶元素放到res数组里，相应count加一，然后对这个新加入res数组的节点的边进行遍历，找出该节点为起点的各边，将终点的入度减一，然后再对顶点进行遍历，入度为0且未访问的顶点进栈，最后的打印程序，就是当res数组的元素个数等于图的顶点数，则打印，否则报错，出现了不连通的情况，再看看主函数，首先对数组G进行初始化，然后进行循环遍历找边，外层循环遍历顶点，内层循环循环可能的终点，输入num1,0表示没边，1表示有边，如果没边就跳过，有边则设置新节点并将它的数据设置为j，然后找顶点i边的最后一个节点，如果i没有边则将新节点设置为边，否则插到边集合的末尾，再增加入度最后调用拓扑排序函数