理解拓扑排序：算法原理与LeetCode实战

最新推荐文章于 2025-07-18 11:41:53 发布

支然苹

最新推荐文章于 2025-07-18 11:41:53 发布

阅读量223

点赞数 5

CC 4.0 BY-SA版权

本文链接：https://blog.csdn.net/gitblog_00384/article/details/148465318

理解拓扑排序：算法原理与LeetCode实战

1. 拓扑排序基础概念

拓扑排序是一种对有向无环图（DAG）进行线性排序的算法。这种排序满足一个关键特性：对于图中的每一条有向边(u, v)，顶点u在排序中总是位于顶点v之前。这种排序方式在解决具有依赖关系的问题时特别有用。

1.1 拓扑排序的特性

有向无环图专属：只有DAG才能进行拓扑排序，有环图无法完成拓扑排序
不唯一性：一个DAG可能有多个有效的拓扑排序结果
应用场景：课程安排、任务调度、编译顺序等依赖关系问题

1.2 拓扑排序示例

考虑一个简单的课程依赖关系：

课程B依赖于课程A
课程C依赖于课程B
课程D依赖于课程A

对应的DAG和可能的拓扑排序：

A → B → C → D
A → D → B → C

2. 拓扑排序的两种实现算法

2.1 Kahn算法（入度表法）

Kahn算法是一种基于贪心思想的拓扑排序算法，通过不断移除入度为0的节点来实现排序。

算法步骤详解

初始化阶段：
- 计算每个节点的入度
- 将所有入度为0的节点加入队列
处理阶段：
- 从队列中取出一个节点，加入结果列表
- 将该节点的所有邻接节点入度减1
- 如果邻接节点入度变为0，加入队列
终止条件：
- 如果结果列表包含所有节点，排序成功
- 否则图中存在环，无法完成拓扑排序

代码实现分析

def topologicalSortingKahn(self, graph: dict):
    indegrees = {u: 0 for u in graph}   # 初始化入度表
    for u in graph:
        for v in graph[u]:
            indegrees[v] += 1           # 计算每个节点的入度
    
    # 初始化队列(使用双端队列提高效率)
    S = collections.deque([u for u in indegrees if indegrees[u] == 0])
    order = []                          # 存储拓扑序列
    
    while S:
        u = S.pop()                     # 取出入度为0的节点
        order.append(u)                 # 加入结果列表
        for v in graph[u]:              
            indegrees[v] -= 1           # 邻接节点入度减1
            if indegrees[v] == 0:       # 如果入度变为0
                S.append(v)             # 加入队列
    
    if len(indegrees) != len(order):    # 检查是否有环
        return []
    return order

2.2 基于DFS的拓扑排序

深度优先搜索也可以实现拓扑排序，利用的是DFS完成顺序的逆序特性。

算法核心思想

当一个节点完成所有邻接节点的访问后，该节点可以视为"已完成"
按照节点完成的顺序逆序排列，就是拓扑排序结果
需要检测图中是否存在环

实现关键点

访问标记：
- visited：记录节点是否被访问过
- onStack：记录当前DFS路径上的节点，用于检测环
后序遍历：
- 节点在完成所有邻接节点访问后才被记录
- 最终需要反转结果列表

代码实现解析

def topologicalSortingDFS(self, graph: dict):
    visited = set()                     # 永久访问标记
    onStack = set()                     # 当前DFS路径标记
    order = []                          
    hasCycle = False                    # 环检测标志
    
    def dfs(u):
        nonlocal hasCycle
        if u in onStack:                # 发现环
            hasCycle = True
            return
        if u in visited or hasCycle:    # 已访问或有环
            return
        
        visited.add(u)                  # 标记访问
        onStack.add(u)                  # 加入当前路径
    
        for v in graph[u]:              # 访问邻接节点
            dfs(v)                      
                
        order.append(u)                 # 后序记录
        onStack.remove(u)               # 移出当前路径
    
    for u in graph:                     # 遍历所有节点
        if u not in visited:
            dfs(u)                      
    
    if hasCycle:                        # 存在环则无解
        return []                       
    order.reverse()                     # 反转后序结果
    return order