在一個有向圖中，對所有的節點進行排序，要求沒有一個節點指向它前面的節點。

先統計所有節點的入度，對於入度為0的節點就可以分離出來，然後把這個節點指向的節點的入度減一。

一直做改操作，直到所有的節點都被分離出來。

如果最後不存在入度為0的節點，那就說明有環，不存在拓撲排序，也就是很多題目的無解的情況。

隊列模板算法：

queue<int>q;
    for(int i=0;i<n;i++)  //n  節點的總數
        if(in[i]==0) q.push(i);  //將入度為0的點入隊列
    vector<int>ans;   //ans 為拓撲序列
 

    while(!q.empty())
    {
        int p=q.top(); q.pop(); // 選一個入度為0的點，出隊列
        ans.push_back(p);
        for(int i=0;i<edge[p].size();i++)
        {
            int y=edge[p][i];
            in[y]--;
            if(in[y]==0)
                q.push(y);  
        }
    }
    if(ans.size()==n)   
    {
        
 
for(int i=0;i<ans.size();i++)
            printf( "%d ",ans[i] );
        printf("\n");
    }
    else printf("No Answer!\n");   //  ans 中的長度與n不相等，就說明無拓撲序列

有些拓撲排序要求字典序最小什麽的，那就把隊列換成優先隊列就好了。

參考代碼

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const
 
 int inf=1e9;
const int maxn=1e6+5;
vector<int>edge[50];
int in[50];
int main()
{
    char s[5];
    set<int>k;
    while(cin>>s)
    {
        k.insert(s[2]-‘A‘);
        k.insert(s[0]-‘A‘);
        if(s[1]==‘>‘)
        {
            in[s[2]-‘A‘]++;
            edge[s[0]-‘A‘].push_back(s[2]-‘A‘);
        }
        else
        {
            in[s[0]-‘A‘]++;
            edge[s[2]-‘A‘].push_back(s[0]-‘A‘);
        }
    }
    priority_queue<int,vector<int>,greater<int> >q;
    for(int i=0;i<30;i++)
    {
        if(in[i]==0&&k.count(i)!=0)
            q.push(i);
    }
    vector<int>ans;
    while(!q.empty())
    {
        int p=q.top(); q.pop();
        ans.push_back(p);
        for(int i=0;i<edge[p].size();i++)
        {
            int y=edge[p][i];
            in[y]--;
            if(in[y]==0&&k.count(y)!=0)
                q.push(y);
        }
    }
    if(ans.size()==k.size())
    {
        for(int i=0;i<ans.size();i++)
            printf("%c",ans[i]+‘A‘);
        printf("\n");
    }
    else printf("No Answer!\n");
    return 0;
}

還有一種比較坑的排序 要求編號小的盡量排在前面，這裏與字典序最小是不一樣的，看一下例題。

HDU-4857

逃生

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 6725 Accepted Submission(s): 1965

Problem Description
糟糕的事情發生啦，現在大家都忙著逃命。但是逃命的通道很窄，大家只能排成一行。

現在有n個人，從1標號到n。同時有一些奇怪的約束條件，每個都形如：a必須在b之前。
同時，社會是不平等的，這些人有的窮有的富。1號最富，2號第二富，以此類推。有錢人就賄賂負責人，所以他們有一些好處。

負責人現在可以安排大家排隊的順序，由於收了好處，所以他要讓1號盡量靠前，如果此時還有多種情況，就再讓2號盡量靠前，如果還有多種情況，就讓3號盡量靠前，以此類推。

那麽你就要安排大家的順序。我們保證一定有解。

Input
第一行一個整數T(1 <= T <= 5),表示測試數據的個數。
然後對於每個測試數據，第一行有兩個整數n(1 <= n <= 30000)和m(1 <= m <= 100000)，分別表示人數和約束的個數。

然後m行，每行兩個整數a和b，表示有一個約束a號必須在b號之前。a和b必然不同。

Output
對每個測試數據，輸出一行排隊的順序，用空格隔開。

Sample Input
15 103 51 42 51 23 41 42 31 53 51 2

Sample Output
1 2 3 4 5

舉個例子如圖：

如果你用優先隊列拓撲排序得到的是：3 5 6 4 1 7 8 9 2 0

但是正確答案為 6 4 1 3 9 2 5 7 8 0 這樣使得小的（1）盡量在前面。

這裏我們可以得到 前面的小的不一定排在前面，但是有一點後面大的一定排在後面。

我們看 6和3不一定3排在前面，因為6後面連了一個更小的數字1能使得6更往前排。

在看 2和 8，8一定排在後面，因為8後面已經沒有東西能使它更往前排（除了0）。

所以最後我們的做法就是 建立一個反圖，跑一邊字典序最大的拓撲排序，最後再把這個排序倒過來就是答案了。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
vector<int>edge[30010],ans;
priority_queue<int>q;
int in[30010];
int T,n,m;
void init()
{
    for(int i=1;i<=n;i++)
    {
        edge[i].clear();
        in[i]=0;
    }
    while(!q.empty()) q.pop();
    ans.clear();
}
void solve()
{
    int i,j;
    for(i=1;i<=n;i++)
        if(in[i]==0) q.push(i);
    while(!q.empty())
    {
        int p=q.top(); q.pop();
        ans.push_back(p);
        for( i=0; i<edge[p].size(); i++ )
        {
            int v=edge[p][i];
            in[v]--;
            if(in[v]==0) q.push(v);
        }
    }
    for(i=ans.size()-1;i>0;i--)
        printf("%d ",ans[i]);
    printf("%d\n",ans[0]);
}
int main()
{
    int a,b;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        init();
        while(m--)
        {
            scanf("%d%d",&a,&b);
            edge[b].push_back(a);
            in[a]++;
        }
        solve();
    }
    return 0;
}

拓撲排序基礎