拓扑排序算法详解

最新推荐文章于 2025-06-30 13:40:45 发布
原创 最新推荐文章于 2025-06-30 13:40:45 发布 · 2k 阅读 · 27 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #图论 #c++ #数据结构 #排序算法

拓扑排序算法详解

基本概念与典型应用场景

拓扑排序（Topological Sorting）是对一个有向无环图（DAG, Directed Acyclic Graph）的所有节点进行排序，使得对于图中的每一条有向边 (u → v)，节点 u 在排序后的序列中都出现在节点 v 之前。这种排序仅在图中不存在有向环路时才有可能实现，因此拓扑排序的前提是图必须是DAG。如果图中含有环（循环依赖），则不存在有效的拓扑序列。

拓扑排序的结果并不唯一——任何满足上述先序约束的线性序列都是该图的一个拓扑排序。一个有向无环图至少会有一种拓扑排序，当存在多个并行不相关的依赖关系时，可能会有多种合法的拓扑序。

典型应用场景：

  • 任务调度： 当一组任务存在先后依赖关系时，可使用拓扑排序确定任务的执行顺序。例如先完成所有前置任务，再执行后续任务。
  • 课程安排： 在课程先修图谱中，拓扑排序可以给出符合先修课要求的课程学习顺序，确保每门课的前置课程都已修完。
  • 编译顺序： 在软件工程中，模块或源文件的编译依赖可表示为DAG，通过拓扑排序计算出编译或构建的正确顺序。
  • 其他依赖解析： 例如解析事件顺序、项目管理中的前后依赖关系、程序包安装顺序（包管理中的依赖解析）等。

在以上场景中，我们都可以抽象出一个有向无环图，其中节点表示任务/课程/模块等元素，有向边表示先后依赖关系。拓扑排序可以帮助我们在线性时间内找出满足所有依赖约束的序列。

两种主要实现方法

拓扑排序有两种常用的实现算法：广度优先搜索（BFS）的 Kahn 算法 和 深度优先搜索（DFS）的后序遍历算法。两种方法时间复杂度均为 $O(N+M)$（其中 $N$ 为节点数，$M$ 为有向边数），能够在线性时间内完成拓扑排序。下面分别介绍这两种算法的原理和实现。

方法一：BFS / Kahn 算法

原理解析： Kahn算法利用**入度（Indegree）**概念实现拓扑排序。入度指向每个节点的入边数量，即有多少其它节点指向该节点。对于DAG而言，至少存在一个入度为0的节点（没有任何前置依赖）。Kahn算法通过不断移除入度为0的节点来实现排序：

  1. 计算入度： 遍历图的所有边，统计每个节点的入度值。
  2. 初始化队列： 将所有入度为0的节点加入队列（表示这些节点可以首先输出，因为它们没有依赖）。
  3. 循环取出节点： 从队列中取出一个入度为0的节点，将其添加到拓扑排序结果序列中；然后将该节点的所有出边删除（模拟移除该节点），相应地将这些出边指向的节点入度减一。
  4. 更新入度及队列： 如果某个邻接节点的入度因此变为0，则将其加入队列，表示它的所有前置节点都已处理，可以输出。
  5. 重复迭代： 不断从队列中取出下一个入度为0的节点处理，直到队列为空。

算法结束后，如果输出的节点数量等于图中的总节点数，说明成功找到了一个拓扑序；若提前队列为空但仍有节点未输出，表示图中仍存在入度不为0的节点，即图中有环，拓扑排序失败。

复杂度分析： Kahn算法需要一次遍历计算所有入度（$O(N+M)$），之后每条边在循环中只会被考虑一次（每条边导致对应节点入度减一操作），因此整体时间复杂度为 $O(N + M)$。空间复杂度主要取决于存储图和队列，约为 $O(N + M)$。

算法特点： 若在选择入度为0节点时有多个可选，Kahn算法可以任选其一输出，因此默认情况下拓扑序可能不唯一。如果需要获得字典序最小的拓扑排序，可以在每次选择入度为0节点时使用小根堆或优先队列选取最小编号的节点，从而保证输出结果的字典序最小。

以下是拓扑排序的 BFS/Kahn 算法的 C++ 实现代码（使用邻接表存储图，并以队列实现BFS）。代码中包含详细注释，便于理解每一步操作：

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 100005;
int N, M;
vector<int> adj[MAXN];    // 邻接表：存储有向图
int indegree[MAXN];       // 入度数组

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    // 假设输入第一行是N和M，接下来M行每行一对u v表示u->v的有向边
    if (!(cin >> N >> M)) {
        return 0;  // 读不到输入时退出
    }
    // 初始化数据结构
    for (int i = 1; i <= N; ++i) {
        adj[i].clear();
        indegree[i] = 0;
    }
    // 读入有向边列表，构建邻接表和入度计数
    for (int i = 0; i < M; ++i) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        indegree[v]++;  // v的入度加一
    }

    // 队列用于存储所有当前入度为0的节点
    queue<int> q;
    for (int i = 1; i <= N; ++i) {
        if (indegree[i] == 0) {
            q.push(i);
        }
    }

    vector<int> topo;  // 存储拓扑排序结果
    topo.reserve(N);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        topo.push_back(u);
        // 遍历u的所有出边，降低相邻节点的入度
        for (int v : adj[u]) {
            indegree[v]--;
            if (indegree[v] == 0) {
                q.push(v);
            }
        }
    }

    // 检查是否所有节点都已输出，否则存在环
    if ((int)topo.size() != N) {
        cout << "Impossible: Graph has a cycle\n";
    } else {
        // 输出拓扑排序结果
        for (int i = 0; i < N; ++i) {
            cout << topo[i] << (i < N - 1 ? ' ' : '\n');
        }
    }

    return 0;
}

上述代码读取图的节点数 N 和边数 M，然后构建图并计算每个节点的入度。接着使用队列实现 Kahn 拓扑排序算法，将排序结果保存在 topo 向量中。最后，根据输出序列长度是否等于 N 来判断是否存在环。如果存在环路，输出提示信息；否则打印出拓扑序列。在实际竞赛题目中，通常会根据题意选择适当的输出格式和环路处理方式（如输出特定提示或不输出等）。

方法二：DFS 后序遍历法

原理解析： 使用深度优先搜索可以方便地实现拓扑排序，基于后序遍历的思想：当一个节点所有相邻的出边（邻居）都被递归处理完后，再将该节点加入结果序列。具体步骤如下：

  1. 初始化标记： 准备一个访问标记数组，用于区分节点状态：未访问、正在访问、已完成访问。通常可以用0/1/2或布尔数组配合递归栈来表示三种状态。

  2. DFS遍历图： 对每个尚未访问的节点执行深度优先搜索。在DFS过程中：

    • 将当前节点标记为“正在访问”（进入递归栈）。
    • 遍历当前节点的所有出边，递归DFS其指向的下一个节点。
    • 在从邻居节点返回后（即当前节点的所有后继都处理完毕），将当前节点标记为“已完成”，并将其加入拓扑序列结果（通常插入到序列头部或使用栈存储，确保当前节点排在其后继节点之前）。

  3. 检测环路： 如果在DFS过程中，遇到一个邻居节点已经被标记为“正在访问”，说明从当前节点出发通过某条路径又回到了这个邻居，形成了环路。这种情况下图不是DAG，应当停止算法并报告无拓扑排序解。

  4. 输出结果： 完成DFS后，收集的结果序列即为拓扑排序。若在DFS过程中结果序列是通过后序插入头部形成的，则可以直接得到正确顺序；若结果存储是逆序的（例如用栈 push），则需要再反转一次序列。

复杂度分析： DFS 算法同样需要遍历图中的每个节点和每条边各一次，时间复杂度为 $O(N + M)$。递归实现需要 $O(N)$ 的栈空间（最坏情况下相当于图的深度）。对于节点数很多且链状很深的图，注意可能出现的递归栈溢出问题，可通过调整递归深度或改用手动栈迭代实现来避免。

算法特点： DFS法实现相对简单直观，而且可以在一次完整DFS过程中自然地检测环路。但要注意处理好节点状态，避免重复访问或漏访问节点。如果需要特定的输出顺序（如字典序最小），DFS本身不易直接实现此要求，一般改用 BFS 方法会更方便控制输出顺序。

下面是使用 DFS 实现拓扑排序的 C++ 示例代码，包含必要的注释说明：

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 100005;
int N, M;
vector<int> adj[MAXN];
int state[MAXN];  // 0=未访问, 1=正在访问, 2=已完成
bool hasCycle = false;
vector<int> topoResult;

void dfs(int u) {
    state[u] = 1;  // 标记为正在访问
    for (int v : adj[u]) {
        if (state[v] == 0) {
            dfs(v);
            if (hasCycle) return;  // 提前结束
        } else if (state[v] == 1) {
            // 遇到回边，发现环路
            hasCycle = true;
            return;
        }
        // 如果state[v] == 2（已完成），直接继续
    }
    state[u] = 2;             // 标记为已完成
    topoResult.push_back(u);  // 后序插入：此时u的后继都已处理，加入结果
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    if (!(cin >> N >> M)) {
        return 0;
    }
    for (int i = 1; i <= N; ++i) {
        adj[i].clear();
        state[i] = 0;
    }
    for (int i = 0; i < M; ++i) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
    }

    topoResult.clear();
    hasCycle = false;
    // 对每个节点尝试DFS
    for (int i = 1; i <= N; ++i) {
        if (state[i] == 0) {
            dfs(i);
            if (hasCycle) break;
        }
    }

    if (hasCycle) {
        cout << "Impossible: Graph has a cycle\n";
    } else {
        // DFS所得拓扑序列在topoResult中是逆序的，需要反转
        reverse(topoResult.begin(), topoResult.end());
        for (int i = 0; i < topoResult.size(); ++i) {
            cout << topoResult[i] << (i < topoResult.size() - 1 ? ' ' : '\n'<