知识点二十三：拓扑排序

前言

我们知道，一个完整的项目往往会包含很多代码源文件。编译器在编译整个项目的时候，需要按照依赖关系，依次编译每个源文件。比如，A.cpp 依赖 B.cpp，那在编译的时候，编译器需要先编译 B.cpp，才能编译 A.cpp。

编译器通过分析源文件或者程序员事先写好的编译配置文件（比如 Makefile 文件），来获取这种局部的依赖关系。那编译器又该如何通过源文件两两之间的局部依赖关系，确定一个全局的编译顺序呢？这个问题的解决思路与“图”这种数据结构的一个经典算法“拓扑排序”有关。

什么是拓扑排序？

这个概念很好理解，我们先来看一个生活中的拓扑排序的例子。日常生活中，我们在穿衣服的时候都有一定的顺序，我们可以把这种顺序想成，衣服与衣服之间有一定的依赖关系。比如说，你必须先穿袜子才能穿鞋，先穿内裤才能穿秋裤。假设现在有八件衣服要穿，它们之间的两两依赖关系我们已经很清楚了，那么该如何安排一个穿衣序列，才能够满足所有的两两之间的依赖关系？

这就是个拓扑排序问题。如下图所示，图中展示了两种满足这些局部先后关系的穿衣序列，实际上，在很多时候，拓扑排序的序列并不是唯一的。

如何确定代码源文件的编译依赖关系？

实际上，开篇关于编译顺序的问题，跟上面这个生活中的例子是一样的，也可以抽象成一个拓扑排序问题。算法是构建在具体的数据结构之上的。针对这个问题，我们先来看下，如何将问题背景抽象成具体的数据结构？

我们可以把源文件与源文件之间的依赖关系，抽象成一个有向图。每个源文件对应图中的一个顶点，源文件之间的依赖关系就是顶点之间的边。如果 a 先于 b 执行，也就是说 b 依赖于 a，那么就在顶点 a 和顶点 b 之间，构建一条从 a 指向 b 的边。而且，这个图不仅要是有向图，还要是一个有向无环图，也就是不能存在像 a->b->c->a 这样的循环依赖关系。因为图中一旦出现环，拓扑排序就无法工作了。实际上，拓扑排序本身就是基于有向无环图的一个算法。

public class Graph { // 定义有向无环图
  private int v; // 顶点的个数
  private LinkedList<Integer> adj[]; // 邻接表

  public Graph(int v) {
    this.v = v;
    adj = new LinkedList[v];
    for (int i=0; i<v; ++i) {
      adj[i] = new LinkedList<>();
    }
  }

  public void addEdge(int s, int t) { // 若s先于t，新建边s->t
    adj[s].add(t);
  }
}

拓扑排序的实现

数据结构定义好后，现在我们来看，如何在这个有向无环图上，实现拓扑排序？拓扑排序有两种实现方法，分别是 Kahn 算法和 DFS 深度优先搜索算法。

1. Kahn 算法

Kahn 算法实际上用的是贪心算法的思想，思路非常简单、好懂。

前面在将问题抽象成具体数据结构的时候，如果 s 需要先于 t 执行，那就添加一条 s 指向 t 的边。所以，如果有向无环图中某个顶点的入度为 0， 也就表示，没有任何顶点必须先于这个顶点执行，那么这个顶点就可以直接执行了。我们先从图中找出一个入度为 0 的顶点，将其输出到拓扑排序的结果序列中（对应代码中就是把它打印出来），并且把这个顶点从图中删除（也就是把这个顶点可达的顶点的入度都减 1）。循环执行上面的过程，直到所有的顶点都被输出。最后输出的序列，就是满足局部依赖关系的全局有序序列。

Kahn 算法的参考代码实现如下：

public void topoSortByKahn() {
  int[] inDegree = new int[v]; // 统计每个顶点的入度，存储到数组 inDegree[v]中
  for (int i = 0; i < v; ++i) {
    for (int j = 0; j < adj[i].size(); ++j) {
      int w = adj[i].get(j); // 如果i->w，则 w 入度+1
      inDegree[w]++;
    }
  }
  LinkedList<Integer> queue = new LinkedList<>(); // 存储入度为 0 的顶点
  for (int i = 0; i < v; ++i) {
    if (inDegree[i] == 0) queue.add(i); // 找到入度为 0 的顶点 i加入到拓扑排序的结果序列中
  }
  while (!queue.isEmpty()) {
    int i = queue.remove(); // 队首元素即入度为 0的顶点出队
    System.out.print("->" + i);
    for (int j = 0; j < adj[i].size(); ++j) { // 顶点 i可达的顶点的入度都减 1
      int k = adj[i].get(j);
      inDegree[k]--; 
      if (inDegree[k] == 0) queue.add(k); // 重新寻找入度为 0 的顶点加入到拓扑排序的结果序列中
    }
  }
}

2. DFS 算法

实际上，拓扑排序也可以用深度优先搜索来实现。关于图上的深度优先搜索算法可以参考这篇博客。不过在这里的名字要稍微改下，更加确切的说法应该是深度优先遍历，遍历图中的所有顶点，而非只是搜索一个顶点到另一个顶点的路径。具体参考代码如下：

public void topoSortByDFS() {
  // 先构建逆邻接表，边s->t表示，s依赖于t，t先于s
  LinkedList<Integer> inverseAdj[] = new LinkedList[v];
  for (int i = 0; i < v; ++i) { // 申请空间
    inverseAdj[i] = new LinkedList<>();
  }
  for (int i = 0; i < v; ++i) { // 通过邻接表生成逆邻接表
    for (int j = 0; j < adj[i].size(); ++j) {
      int w = adj[i].get(j); // i->w
      inverseAdj[w].add(i); // w->i
    }
  }
  boolean[] visited = new boolean[v];
  for (int i = 0; i < v; ++i) { // 深度优先遍历图
    if (visited[i] == false) {
      visited[i] = true;
      dfs(i, inverseAdj, visited);
    }
  }
}

private void dfs(
    int vertex, LinkedList<Integer> inverseAdj[], boolean[] visited) {
  for (int i = 0; i < inverseAdj[vertex].size(); ++i) {
    int w = inverseAdj[vertex].get(i);
    if (visited[w] == true) continue;
    visited[w] = true;
    dfs(w, inverseAdj, visited);
  } // 先把vertex这个顶点可达的所有顶点都打印出来之后，再打印它自己
  System.out.print("->" + vertex);
}

这个算法包含两个关键部分。

1. 第一部分是通过邻接表构造逆邻接表。邻接表中，边 s->t 表示 s 先于 t 执行，也就是 t 要依赖 s。在逆邻接表中，边 s->t 表示 s 依赖于 t，s 后于 t 执行。
2. 第二部分是这个算法的核心，也就是递归处理每个顶点。对于顶点 vertex 来说，我们先输出它可达的所有顶点，也就是说，先把它依赖的所有的顶点输出了，然后再输出自己。

3. 两种算法的时间复杂度分析

从 Kahn 代码中可以看出来，每个顶点被访问了一次，每个边也都被访问了一次，所以，Kahn 算法的时间复杂度就是 O(V+E)（V 表示顶点个数，E 表示边的个数）。

而在 DFS 算法的代码实现中，每个顶点被访问了两次（构建逆邻接表和遍历图），每条边都被访问一次，所以时间复杂度也是 O(V+E)。

注意：这里的图不一定都是连通的，有可能是由好几个不连通的子图构成，所以，E 并不一定大于 V，两者的大小关系不确定。因此，在表示时间复杂度的时候，V、E 都要考虑在内。

利用拓扑排序检测图中环的存在

实际上，拓扑排序的应用非常广泛，解决的问题的模型也非常一致。凡是需要通过局部顺序来推导全局顺序的，一般都能用拓扑排序来解决。除此之外，拓扑排序还能检测图中环的存在。比如拿 Kahn 算法来说，如果最后输出的顶点个数少于图中的顶点个数，也就是图中还有入度不是 0 的顶点时，那就说明图中存在环。

关于图中环的检测，我们在递归那一节讲过一个例子，在查找最终推荐人的时候，可能会因为脏数据，造成死循环推荐，比如，用户 A 推荐了用户 B，用户 B 推荐了用户 C，用户 C 又推荐了用户 A。如何避免这种脏数据导致的无限递归？

实际上，这就是环的检测问题。我们要做的就是自动检测出 A-B-C-A 这种“环”的存在，在这个问题中，我们每次都只是要查找一个用户的最终推荐人，所以，并不需要动用复杂的拓扑排序算法，而只需要记录已经访问过的用户 ID，当某个用户 ID 第二次被访问的时候，就说明存在环，也就说明存在脏数据。我们可以用一个散列表存储已经访问过的用户 ID.

HashSet<Integer> hashTable = new HashSet<>(); // 保存已经访问过的用户Id
long findRootReferrerId(long actorId) {
  if (hashTable.contains(actorId)) { // 新来的用户ID就先查这个表里面有没有，如果在表中找到该ID，说明存在环
    return;
  }
  hashTable.add(actorId); // 把查询过的元素添加到表中
  Long referrerId = select referrer_id from [table] where actor_id = actorId; // 找到当前 ID的推荐用户
  if (referrerId == null) return actorId; // 没有推荐人就直接返回
  return findRootReferrerId(referrerId); // 递归调用
}

如果把这个问题稍微改一下，换成要检测数据库中的所有用户之间的推荐关系中，有没有存在环的情况。那这个问题，就需要用到拓扑排序算法了。我们可以把用户之间的推荐关系，从数据库中加载到内存中，然后构建成有向图的结构，再利用拓扑排序，就可以快速检测出图中是否存在环了。

小结

一、拓扑排序
1.定义：对一个有向无环图(Directed Acyclic Graph简称DAG) G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点 u和 v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。
2.在很多时候，拓扑排序的序列并不是唯一的。

二、拓扑排序的实现
1.拓扑排序有两种实现方法，分别是 Kahn 算法和 DFS 深度优先搜索算法。
2.Kahn 算法实际上用的是贪心算法的思想，先从图中找出一个入度为 0 的顶点，将其输出到拓扑排序的结果序列中，并且把这个顶点从图中删除（也就是把这个顶点可达的顶点的入度都减 1）。循环执行上面的过程，直到所有的顶点都被输出。最后输出的序列，就是满足局部依赖关系的全局有序序列。
3.DFS 算法则是深度优先遍历图中的所有顶点，构造逆邻接表，然后递归处理每个顶点，先把它依赖的所有的顶点输出了，然后再输出自己。
4.两种算法的时间复杂度均为 O(V+E)，其中 V 表示顶点个数，E 表示边的个数。

三、拓扑排序的应用
1.图中环的检测
2.确定代码源文件的编译依赖关系

参考

《数据结构与算法之美》
王争
前Google工程师