拓扑排序的定义
对一个有向无环图G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。
拓扑排序的应用
参考一道ACM题目确定比赛名次
问题描述：
有N个比赛队（1<=N<=500），编号依次为1，2，3，。。。。，N进行比赛，比赛结束后，裁判委员会要将所有参赛队伍从前往后依次排名，但现在裁判委员会不能直接获得每个队的比赛成绩，只知道每场比赛的结果，即P1赢P2，用P1，P2表示，排名时P1在P2之前。现在请你编程序确定排名。
现已知有4个队伍参加比赛，而每两队的比赛成绩如下:
1 2
2 3
4 3
1，2表示即P1队赢了P2队。先让你排序出整个比赛的排名该问题的求解过程如下：
完全可将P1～P4的比赛排名按题目要求构建出一个有向图：
P1 —> P2 —> P3 <— P4
由图自然非常清楚的看出排名为P1，P2，P4, P3或P1，P4，P2, P3
如果我们考虑图的相关性质在里面，会发现：
入度为 0 的顶点 P1 是排序中的第一名(因为没有任何人战胜它)，而确定好第一名之后，将第一名从排序中踢出，剩下的图： P2–> P3 <– P4 中，依然存在入度为0的节点，依次类推，便得到了一个求拓扑排序的算法。
拓扑排序存在的条件
并不是所有图都存在拓扑排序，拓扑排序在图中也不是唯一的(例如上例中将存在两个拓扑排序)。
不含环路的有向图必包含入度为零的顶点—因此一定存在拓扑排序
拓扑排序的算法实现
入度为 0 的顶点 m（及其关联边）从图 G 中取出，则剩余的 G’依然是有向无环图，故其拓扑排序也必然存在。从递归的角度看，一旦得到了 G’ 的拓扑排序，只需将 m 作为最大顶点插入，即可得到 G 的拓扑排序。如此，我们已经得到了一个拓扑排序的算法。
上图给出了拓扑排序的一种实现思路(不同的递归入度为0的节点)，现在从另一角度—图的DFS搜索入手，来实现一个效率更高的拓扑排序
回顾笔者的上一篇博文图的深度优先搜索算法并生成DFS树
。
对于节点包含如下几个类型：
private int status = 0; //状态 0 undiscovered "未发现" 1 discovered "已发现" 2 visited "已完成"对于弧有如下类型：
private int type;
//弧类型：0 CROSS 跨边 1 TREE（支撑树）
//2 BACKWARD(该弧的起点和终点在支撑树中存在终点到起点的路径)
//3 FORWARD (该弧的起点和终点在支撑树中存在其他路径依然可以从起点到终点)你会发现，在对有向无环图的DFS搜索中，首先因访问完成而转换至“2 - 已完成“状态的顶点m就是出度为0的节点—-也就是在拓扑排序中最末尾的节点。
进一步地，根据 DFS 搜索的特性，顶点 m（及其关联边）对此后的搜索过程将不起任何作用。于是，下一转换至 “2 - 已完成“ 状态的顶点可等效地理解为是，从图中剔除顶点 m（及其关联边）之后的出度为零者 — 在拓扑排序中，该顶点应为顶点 m 的前驱。由此可见，DFS 搜索过程中各顶点被标记为 “2 -已完成“ 的次序，恰好（按逆序）给出了原图的一个拓扑排序。
此外，基于DFS 可以检测环路的特性，恰好可以用来判别输入是否为有向无环图。在搜索过程中一旦发现后向边(2 - BACKWARD)，即可抛出异常“存在环路，无法拓扑排序“。
基于DFS搜索，求拓扑排序的代码实现
public List toSort() throws Exception{
List<Integer> result = new LinkedList<Integer>();
int index = 0;
int s = index;
Stack<Integer> stack = new Stack<Integer>();
do {
if(allNodes[s].getStatus() == 0){
sort(s, stack, result);
}
}while(index != (s = (++s%size))); //避免依赖index无法到达的节点
return result;
}
public void sort(int index, Stack<Integer> stack, List<Integer> result ) throws Exception {
stack.push(index);
allNodes[index].setStatus(1);
while(!stack.isEmpty()) {
int current = stack.peek();
Node node = allNodes[current];
boolean isVisited = true;
//寻找所有子节点(如果是邻接表的实现此处可以优化)
for(int i=0;i<size;i++) {
if(getEdge(current,i)!=null) {
switch(allNodes[i].getStatus()) {
case 0:
//发现下一个节点和支撑树的边
stack.push(i);
allNodes[i].setStatus(1);
isVisited = false;
break;
case 1:
//发现后向边，存在环路，抛出异常
throw new Exception("存在环路，无法排序");
case 2:
break;
}
}
}
//标记为已完成
if(isVisited) {
node.setStatus(2);
result.add(current);
stack.removeElement(current);
}
}
}
这端代码基于笔者前两篇文章：
图的邻接表的实现
图的深度优先搜索算法并生成DFS树
现在使用上述的代码来完成上图的排序
public static void toSort() throws Exception {
AdjacencyList list = new AdjacencyList();
int aIndex = list.addNode(new adjacencyList.Node<String>("a")); //索引为0
int bIndex = list.addNode(new adjacencyList.Node<String>("b")); //索引为1
int cIndex = list.addNode(new adjacencyList.Node<String>("c")); //索引为2
int dIndex = list.addNode(new adjacencyList.Node<String>("d")); //索引为3
int eIndex = list.addNode(new adjacencyList.Node<String>("e")); //索引为4
int fIndex = list.addNode(new adjacencyList.Node<String>("f")); //索引为5
adjacencyList.Edge<String> acEdge = new adjacencyList.Edge<String>(cIndex, "这是边a到c的弧", 1);
adjacencyList.Edge<String> adEdge = new adjacencyList.Edge<String>(dIndex, "这是边a到d的弧",1);
adjacencyList.Edge<String> bcEdge = new adjacencyList.Edge<String>(cIndex, "这是边b到c的弧",1);
adjacencyList.Edge<String> cdEdge = new adjacencyList.Edge<String>(dIndex, "这是边c到d的弧",1);
adjacencyList.Edge<String> cfEdge = new adjacencyList.Edge<String>(fIndex, "这是边c到f的弧",1);
adjacencyList.Edge<String> ceEdge = new adjacencyList.Edge<String>(eIndex, "这是边c到e的弧",1);
adjacencyList.Edge<String> efEdge = new adjacencyList.Edge<String>(fIndex, "这是边c到e的弧",1);
list.setEdge(aIndex, acEdge);
list.setEdge(aIndex, adEdge);
list.setEdge(bIndex, bcEdge);
list.setEdge(cIndex, cdEdge);
list.setEdge(cIndex, ceEdge);
list.setEdge(cIndex, cfEdge);
list.setEdge(eIndex, efEdge);
System.out.println(list.toSort());
//输出[3, 5, 4, 2, 0, 1]
}当如上图A，B或D，F所示，存在多个入度为0或出度为0(极大，极小元素)会导致拓扑排序结果不唯一
复杂度
这里仅额外引入的栈其规模不超过顶点总数 0 (n）。总体而言，空间复杂度与基本的深度优先搜索算法同样，仍为 O (n + e）。该算法的递归跟踪过程与标准 DFS 搜索完全一致，且各递归实例自身的执行时间依然保持为 0 (1），故总体运行时间仍为 O (n + e）。