拓扑排序：Kahn算法与DFS算法

于 2024-08-05 22:59:44 发布
阅读量338 收藏 6
点赞数 17
分类专栏： 从0开始学算法 文章标签： 算法 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40254606/article/details/140939089
版权

引言

拓扑排序是有向无环图（DAG）中的一种线性排序，使得对于图中的每一条有向边 ( u \rightarrow v )，顶点 ( u ) 在排序中出现在顶点 ( v ) 之前。本文将详细介绍两种实现拓扑排序的算法：Kahn算法和基于深度优先搜索（DFS）的算法。

目录

  1. Kahn算法
  2. 基于DFS的算法

Kahn算法

定义

Kahn算法是一种基于入度的拓扑排序算法。该算法通过不断移除入度为0的顶点及其边来构建拓扑排序。

算法步骤

  1. 初始化：计算图中所有顶点的入度，并将所有入度为0的顶点添加到一个队列中。
  2. 构建排序：从队列中取出一个顶点，将其添加到拓扑排序的结果中，并移除该顶点及其所有出边。对于每个被移除的出边，如果目标顶点的入度减为0，则将该顶点添加到队列中。
  3. 检测环：重复步骤2，直到队列为空。如果排序结果中的顶点数量小于图中的顶点数量，则说明图中存在环，无法进行拓扑排序。

示例

假设我们有一个有向无环图，顶点集合为 ({A, B, C, D, E, F})，边集合为 ({(A, C), (B, C), (B, D), (C, E), (D, F), (E, F)})。
A
C
B
D
E
F

Kahn算法实现

下面是用Java实现Kahn算法的代码示例：

import java.util.*;

public class KahnAlgorithm {
    private int vertices; // 顶点数量
    private List<Integer>[] adjList; // 邻接表

    public KahnAlgorithm(int vertices) {
        this.vertices = vertices;
        adjList = new List[vertices];
        for (int i = 0; i < vertices; i++) {
            adjList[i] = new ArrayList<>();
        }
    }

    // 添加边
    public void addEdge(int src, int dest) {
        adjList[src].add(dest);
    }

    // Kahn算法实现的拓扑排序
    public void topologicalSort() {
        int[] inDegree = new int[vertices];
        for (int i = 0; i < vertices; i++) {
            for (int dest : adjList[i]) {
                inDegree[dest]++;
            }
        }

        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < vertices; i++) {
            if (inDegree[i] == 0) {
                queue.add(i);
            }
        }

        List<Integer> topOrder = new ArrayList<>();
        while (!queue.isEmpty()) {
            int u = queue.poll();
            topOrder.add(u);

            for (int neighbor : adjList[u]) {
                if (--inDegree[neighbor] == 0) {
                    queue.add(neighbor);
                }
            }
        }

        if (topOrder.size() != vertices) {
            System.out.println("图中存在环，无法进行拓扑排序");
            return;
        }

        System.out.println("拓扑排序结果：");
        for (int node : topOrder) {
            System.out.print(node + " ");
        }
    }

    public static void main(String[] args) {
        KahnAlgorithm graph = new KahnAlgorithm(6);
        graph.addEdge(0, 2);
        graph.addEdge(1, 2);
        graph.addEdge(1, 3);
        graph.addEdge(2, 4);
        graph.addEdge(3, 5);
        graph.addEdge(4, 5);
        graph.topologicalSort();
    }
}

代码注释

  1. 类和构造函数：

    public class KahnAlgorithm {
    private int vertices; // 顶点数量
    private List<Integer>[] adjList; // 邻接表

    public KahnAlgorithm(int vertices) {
        this.vertices = vertices;
        adjList = new List[vertices];
        for (int i = 0; i < vertices; i++) {
            adjList[i] = new ArrayList<>();
        }
    }

    KahnAlgorithm 类包含图的顶点数量和邻接表，并有一个构造函数来初始化这些变量。

  2. 添加边：

    public void addEdge(int src, int dest) {
    adjList[src].add(dest);
}

    addEdge 方法用于向图中添加边。

  3. Kahn算法的拓扑排序：

    public void topologicalSort() {
    int[] inDegree = new int[vertices];
    for (int i = 0; i < vertices; i++) {
        for (int dest : adjList[i]) {
            inDegree[dest]++;
        }
    }

    Queue<Integer> queue = new LinkedList<>();
    for (int i = 0; i < vertices; i++) {
        if (inDegree[i] == 0) {
            queue.add(i);
        }
    }

    List<Integer> topOrder = new ArrayList<>();
    while (!queue.isEmpty()) {
        int u = queue.poll();
        topOrder.add(u);

        for (int neighbor : adjList[u]) {
            if (--inDegree[neighbor] == 0) {
                queue.add(neighbor);
            }
        }
    }

    if (topOrder.size() != vertices) {
        System.out.println("图中存在环，无法进行拓扑排序");
        return;
    }

    System.out.println("拓扑排序结果：");
    for (int node : topOrder) {
        System.out.print(node + " ");
    }
}

    topologicalSort 方法实现了Kahn算法，进行拓扑排序。

  4. 主函数：

    public static void main(String[] args) {
    KahnAlgorithm graph = new KahnAlgorithm(6);
    graph.addEdge(0, 2);
    graph.addEdge(1, 2);
    graph.addEdge(1, 3);
    graph.addEdge(2, 4);
    graph.addEdge(3, 5);
    graph.addEdge(4, 5);
    graph.topologicalSort();
}

    main 方法创建一个图并进行拓扑排序。

Kahn算法的执行过程图解

取出顶点F
取出顶点E
取出顶点D
取出顶点C
取出顶点B
取出顶点A
初始化入度和队列
入度为0
入度为0
取出A
取出B
取出C
取出D
取出E
取出F
结果: A, B, C, D, E, F
队列: F
结果: A, B, C, D, E
队列: E, F
移除E的出边
结果: A, B, C, D
队列: D, E
移除D的出边
结果: A, B, C
队列: C, D
移除C的出边
结果: A, B
队列: B, C
移除B的出边
结果: A
队列: A, B
移除A的出边
加入队列
顶点 A
加入队列
顶点 B

基于DFS的算法

定义

基于DFS的拓扑排序算法通过递归的方式遍历图的每个顶点，并在访问完所有邻接顶点后将顶点压入栈中，最终从栈顶依次弹出顶点即为拓扑排序结果。

算法步骤

  1. 初始化：创建一个栈用于存储排序结果，标记所有顶点为未访问。
  2. DFS遍历：对于每个未访问的顶点，进行DFS遍历。递归访问该顶点的所有邻接顶点，访问完毕后将该顶点压入栈中。
  3. 构建排序：重复步骤2，直到所有顶点都被访问。最后从栈顶

依次弹出顶点即为拓扑排序结果。

示例

假设我们有一个有向无环图，顶点集合为 ({A, B, C, D, E, F})，边集合为 ({(A, C), (B, C), (B, D), (C, E), (D, F), (E, F)})。
A
C
B
D
E
F

基于DFS的算法实现

下面是用Java实现基于DFS的拓扑排序算法的代码示例：

import java.util.*;

public class DFSTopologicalSort {
    private int vertices; // 顶点数量
    private List<Integer>[] adjList; // 邻接表

    public DFSTopologicalSort(int vertices) {
        this.vertices = vertices;
        adjList = new List[vertices];
        for (int i = 0; i < vertices; i++) {
            adjList[i] = new ArrayList<>();
        }
    }

    // 添加边
    public void addEdge(int src, int dest) {
        adjList[src].add(dest);
    }

    // 递归实现DFS
    private void DFS(int vertex, boolean[] visited, Stack<Integer> stack) {
        visited[vertex] = true;
        for (int neighbor : adjList[vertex]) {
            if (!visited[neighbor]) {
                DFS(neighbor, visited, stack);
            }
        }
        stack.push(vertex);
    }

    // 基于DFS的拓扑排序
    public void topologicalSort() {
        Stack<Integer> stack = new Stack<>();
        boolean[] visited = new boolean[vertices];
        for (int i = 0; i < vertices; i++) {
            if (!visited[i]) {
                DFS(i, visited, stack);
            }
        }

        System.out.println("拓扑排序结果：");
        while (!stack.isEmpty()) {
            System.out.print(stack.pop() + " ");
        }
    }

    public static void main(String[] args) {
        DFSTopologicalSort graph = new DFSTopologicalSort(6);
        graph.addEdge(0, 2);
        graph.addEdge(1, 2);
        graph.addEdge(1, 3);
        graph.addEdge(2, 4);
        graph.addEdge(3, 5);
        graph.addEdge(4, 5);
        graph.topologicalSort();
    }
}

代码注释

  1. 类和构造函数：

    public class DFSTopologicalSort {
    private int vertices; // 顶点数量
    private List<Integer>[] adjList; // 邻接表

    public DFSTopologicalSort(int vertices) {
        this.vertices = vertices;
        adjList = new List[vertices];
        for (int i = 0; i < vertices; i++) {
            adjList[i] = new ArrayList<>();
        }
    }

    DFSTopologicalSort 类包含图的顶点数量和邻接表，并有一个构造函数来初始化这些变量。

  2. 添加边：

    public void addEdge(int src, int dest) {
    adjList[src].add(dest);
}

    addEdge 方法用于向图中添加边。

  3. 递归实现DFS：

    private void DFS(int vertex, boolean[] visited, Stack<Integer> stack) {
    visited[vertex] = true;
    for (int neighbor : adjList[vertex]) {
        if (!visited[neighbor]) {
            DFS(neighbor, visited, stack);
        }
    }
    stack.push(vertex);
}

    DFS 方法递归访问顶点及其邻接顶点，并在访问完所有邻接顶点后将顶点压入栈中。

  4. 基于DFS的拓扑排序：

    public void topologicalSort() {
    Stack<Integer> stack = new Stack<>();
    boolean[] visited = new boolean[vertices];
    for (int i = 0; i < vertices; i++) {
        if (!visited[i]) {
            DFS(i, visited, stack);
        }
    }

    System.out.println("拓扑排序结果：");
    while (!stack.isEmpty()) {
        System.out.print(stack.pop() + " ");
    }
}

    topologicalSort 方法实现了基于DFS的拓扑排序，输出拓扑排序结果。

  5. 主函数：

    public static void main(String[] args) {
    DFSTopologicalSort graph = new DFSTopologicalSort(6);
    graph.addEdge(0, 2);
    graph.addEdge(1, 2);
    graph.addEdge(1, 3);
    graph.addEdge(2, 4);
    graph.addEdge(3, 5);
    graph.addEdge(4, 5);
    graph.topologicalSort();
}

    main 方法创建一个图并进行拓扑排序。

基于DFS算法的执行过程图解

输出结果
DFS遍历顶点1
DFS遍历顶点0
初始化
从栈顶依次弹出顶点
拓扑排序结果:0 1 3 2 4 5
访问顶点1
顶点1
顶点1的邻接顶点3
访问顶点3
顶点3的邻接顶点5
顶点5已访问,跳过
将顶点3压入栈中
将顶点1压入栈中
访问顶点0
顶点0
顶点0的邻接顶点2
访问顶点2
顶点2的邻接顶点4
访问顶点4
顶点4的邻接顶点5
访问顶点5
将顶点5压入栈中
将顶点4压入栈中
将顶点2压入栈中
创建栈
标记所有顶点为未访问

结论

通过上述讲解和实例代码，我们详细展示了Kahn算法和基于DFS的拓扑排序算法的定义、步骤及其实现。希望这篇博客对您有所帮助！

如果您觉得这篇文章对您有帮助，请关注我的CSDN博客，点赞并收藏这篇文章，您的支持是我持续创作的动力！

关键内容总结：

  • Kahn算法的定义和实现
  • 基于DFS的拓扑排序算法的定义和实现
  • 两种算法的执行过程图解

推荐阅读：深入探索设计模式专栏，详细讲解各种设计模式的应用和优化。点击查看：深入探索设计模式。

特别推荐：设计模式实战专栏，深入解析设计模式的实际应用，提升您的编程技巧。点击查看：设计模式实战。

如有任何疑问或建议，欢迎在评论区留言讨论。谢谢阅读！

捕风捉你
关注
  • 17
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
43丨拓扑排序：如何确定代码源文件的编译依赖关系？1
08-03
`addEdge`方法用于添加边，而`topoSort`方法则实现拓扑排序，可以采用Kahn算法或DFS。 **总结引申**： 拓扑排序不仅应用于编译系统的依赖处理，还广泛用于任务调度、流程规划等领域，只要是需要确定有序执行且不...
VC++拓扑排序算法
12-11
总结来说，拓扑排序是一种对有向无环图进行线性排列的方法，在VC++中可以通过多种算法实现，如Kahn算法或基于DFS/BFS的算法。理解拓扑排序的基本原理并能熟练地在VC++中实现，对于学习图论和数据结构的深入理解至关...
拓扑排序（kahn算法和dfs算法）
dztom的博客
11-27 639
拓扑排序（两种算法）
C语言 拓扑排序（Kahn算法和DFS算法实现）
m0_73070900的博客
06-05 1181
Kahn算法和DFS算法都可以实现拓扑排序，二者均对顶点进行入度计数，但他们的实现方式不同，各有特点。Kahn算法使用栈或队列进行操作，实现过程简单且极易理解；而DFS算法则更加优美，同时也使用了栈的思想。然而，当面对大规模数据时，Kahn算法通常会更快一些。总之，两种算法都是在时间复杂度(n为顶点数，e为边数)的情况下解决任务调度问题、编译依赖等问题的简单有效方法。
拓扑排序（Topological Sorting）：Kahn 算法和 DFS 算法
Dong_HFUT的博客
04-16 3658
拓扑排序算法 Topological sorting algorithmKahn 算法DFS 算法 拓扑排序（TopoSort）有相当广泛的应用，比如依赖关系分析、图中是否有环、编译优化中的数据刘分析等。 拓扑排序，就是任意一条边 u->v，节点 u 都先于节点 v 。 显然，有向图中有环的话，就不存在拓扑排序，所以我们讲的拓扑排序是针对有向无环图（DAG）的。拓扑排序可能不是唯一的，如下图，ABDCEF 、ABDECF 和 ABCDEF 都是这个 DAG 的拓扑排序。 上文 图的邻接矩阵、邻接
拓扑排序Kahn算法与DFS算法
重生之我是cxk的博客
07-07 182
给定一个有向无环图(DAG)，排出所有顶点的一个序列A满足：对于图中每条有向边(x,y),x在A中都出现在y之前，则A是该图中的顶点的一个拓扑序拓扑排序可以判断 有向图中是否有环 ，可以生成拓扑序列。
图论算法—图的拓扑排序介绍和Kahn算法原理解析以及Java代码的实现
终生学习践行者
05-18 3524
介绍了图的拓扑排序的概念以及求拓扑序列的算法：Kahn算法的原理，最后提供了基于邻接矩阵和邻接表的图对该算法的Java实现。
拓扑排序【kahn算法及dfs的拓扑排序】
fl_334正经的码棚
05-09 501
家谱树 有个人的家族很大，辈分关系很混乱，请你帮整理一下这种关系。给出每个人的孩子的信息。输出一个序列，使得每个人的后辈都比那个人后列出 Sample Input 5 0 4 5 1 0 1 0 5 3 0 3 0 样例输出 Sample Output 2 4 5 3 1 【因为需输出字典序最小的因而要使用优先队列】 #include&amp;lt;iostream&amp;gt; #...
拓扑排序的两种实现：Kahn算法和dfs算法
热门推荐
qinzhaokun的专栏
09-18 1万+
本文将从以下几个方面介绍拓扑排序： 拓扑排序的定义和前置条件和离散数学中偏序/全序概念的联系 典型实现算法 Kahn算法基于DFS的算法 解的唯一性问题 实际例子 取材自以下材料： http://en.wikipedia.org/wiki/Topological_sorting http://en.wikipedia.org/wiki
拓扑排序(Kahn算法和基于DFS求解法)
yo_bc的博客
06-07 4032
拓扑排序是对有向无环图(DAG)进行排序，从而找到一个序列。该序列满足对于任意一对不同的顶点u,v∈V，若G中存在一条从u->v的边，则在此序列中u在v前面。 拓扑排序也可以用来判断一个有向图是否存在环。 有两种算法可以求得该序列： 1.Kahn算法。 其实就是不断的寻找有向图中没有前驱(入度为0)的顶点，将之输出。然后从有向图中删除所有以此顶点为尾的弧。重复操作，直至图空，或者找
【算法设计与数据结构】拓扑排序算法的实现——Kahn算法及基于dfs的算法
jiange_zh的博客
09-02 4829
拓扑排序的定义和原理等我不再赘述，各种教材和网络上都有详细解释，今天我主要谈一谈两种实现拓扑排序的算法——Kahn算法和基于dfs的算法
top.rar_拓扑排序
09-19
在这个场景中，"top.rar_拓扑排序"是一个使用VC++.NET 2003编写的程序，用于实现拓扑排序算法，并应用于排课问题。排课是一个典型的调度问题，需要解决课程之间的依赖关系，确保没有时间冲突。在这个程序中，课程被...
图的存储遍历拓扑排序
04-09
9. **挑战与提高**：除了基础概念，还可以研究Kahn算法、Tarjan算法等拓扑排序的优化方法，以及如何在复杂图结构中应用图的遍历和排序。 总之，这个资源包提供了全面的图论学习材料，无论是对初学者还是进阶者，都...
括号匹配，迷宫算法，一元多项式运算，拓扑排序
10-09
有多种方法可以实现拓扑排序，如Kahn算法和深度优先搜索的变体。拓扑排序在项目管理、任务调度和依赖关系分析等方面具有重要价值。 总的来说，这四个知识点覆盖了数据结构、算法和计算数学的基础内容。掌握它们不仅...
浅谈用二分和三分法解决问题（c++）
2301_79587247的博客
07-29 890
头牛不满于隔间的位置分布，它们为牛棚里其他的牛的存在而愤怒。为了防止牛之间的互相打斗，Farmer John 想把这些牛安置在指定的隔间，所有牛中相邻两头的最近距离越大越好。而如果某个问题的解空间是单峰的，不管是向外凸还是向内凹，都可以用另一种算法解决，三分。的数列，我们需要找出该数列的一个子串，使得子串平均数最大化，并且子串长度。顾名思义，三分就是一种把解空间分成三段的算法，答案一定在某个段内，时间是。门考试成绩，您的累积平均成绩的可能最大值是多少。的数量应该尽可能的多，并且当她的 IQ 为。
学习笔记--算法（双指针）3
最新发布
weixin_71085457的博客
08-01 822
学习笔记，自用！！！
学习笔记--算法（双指针）2
weixin_71085457的博客
08-01 594
学习笔记，自用！！
【前端面试】七、算法-数组展平
weixin_49015558的博客
07-29 310
1.判断数组 2.二维数组展平 3.多维数组展平
请用c语言实现并写出以下代码: 实现拓扑排序的Kahn算法、DFS算法
07-22
以下是用C语言实现拓扑排序的Kahn算法和DFS算法的示例代码： 1. 拓扑排序的Kahn算法： ```c #include <stdio.h> #include <stdlib.h> #define MAX_SIZE 100 struct Node { int data; struct Node* next; }; struct Graph { int numVertices; struct Node** adjLists; int* indegree; }; struct Node* createNode(int data) { struct Node* newNode = malloc(sizeof(struct Node)); newNode->data = data; newNode->next = NULL; return newNode; } struct Graph* createGraph(int vertices) { struct Graph* graph = malloc(sizeof(struct Graph)); graph->numVertices = vertices; graph->adjLists = malloc(vertices * sizeof(struct Node*)); graph->indegree = malloc(vertices * sizeof(int)); int i; for (i = 0; i < vertices; i++) { graph->adjLists[i] = NULL; graph->indegree[i] = 0; } return graph; } void addEdge(struct Graph* graph, int src, int dest) { struct Node* newNode = createNode(dest); newNode->next = graph->adjLists[src]; graph->adjLists[src] = newNode; graph->indegree[dest]++; } void topologicalSort(struct Graph* graph) { int* result = malloc(graph->numVertices * sizeof(int)); int front = 0, rear = 0; int* indegree = graph->indegree; int i; for (i = 0; i < graph->numVertices; i++) { if (indegree[i] == 0) { result[rear++] = i; } } while (front != rear) { int currentVertex = result[front++]; struct Node* temp = graph->adjLists[currentVertex]; while (temp) { int adjVertex = temp->data; indegree[adjVertex]--; if (indegree[adjVertex] == 0) { result[rear++] = adjVertex; } temp = temp->next; } } if (rear != graph->numVertices) { printf("Graph contains a cycle!\n"); return; } printf("Topological Sort:"); for (i = 0; i < graph->numVertices; i++) { printf(" %d", result[i]); } printf("\n"); } int main() { int vertices, edges; printf("Enter the number of vertices: "); scanf("%d", &vertices); printf("Enter the number of edges: "); scanf("%d", &edges); struct Graph* graph = createGraph(vertices); int i, src, dest; for (i = 0; i < edges; i++) { printf("Enter edge %d (source destination): ", i+1); scanf("%d %d", &src, &dest); addEdge(graph, src, dest); } topologicalSort(graph); return 0; } ``` 2. 拓扑排序的DFS算法： ```c #include <stdio.h> #include <stdlib.h> #define MAX_SIZE 100 struct Node { int data; struct Node* next; }; struct Graph { int numVertices; struct Node** adjLists; int* visited; }; struct Node* createNode(int data) { struct Node* newNode = malloc(sizeof(struct Node)); newNode->data = data; newNode->next = NULL; return newNode; } struct Graph* createGraph(int vertices) { struct Graph* graph = malloc(sizeof(struct Graph)); graph->numVertices = vertices; graph->adjLists = malloc(vertices * sizeof(struct Node*)); graph->visited = malloc(vertices * sizeof(int)); int i; for (i = 0; i < vertices; i++) { graph->adjLists[i] = NULL; graph->visited[i] = 0; } return graph; } void addEdge(struct Graph* graph, int src, int dest) { struct Node* newNode = createNode(dest); newNode->next = graph->adjLists[src]; graph->adjLists[src] = newNode; } void DFS(struct Graph* graph, int vertex, int* result, int* index) { struct Node* adjList = graph->adjLists[vertex]; graph->visited[vertex] = 1; while (adjList) { int connectedVertex = adjList->data; if (!graph->visited[connectedVertex]) { DFS(graph, connectedVertex, result, index); } adjList = adjList->next; } result[(*index)++] = vertex; } void topologicalSort(struct Graph* graph) { int* result = malloc(graph->numVertices * sizeof(int)); int index = 0; int i; for (i = 0; i < graph->numVertices; i++) { if (!graph->visited[i]) { DFS(graph, i, result, &index); } } printf("Topological Sort:"); for (i = graph->numVertices - 1; i >= 0; i--) { printf(" %d", result[i]); } printf("\n"); } int main() { int vertices, edges; printf("Enter the number of vertices: "); scanf("%d", &vertices); printf("Enter the number of edges: "); scanf("%d", &edges); struct Graph* graph = createGraph(vertices); int i, src, dest; for (i = 0; i < edges; i++) { printf("Enter edge %d (source destination): ", i+1); scanf("%d %d", &src, &dest); addEdge(graph, src, dest); } topologicalSort(graph); return 0; } ``` 这些代码可以帮助您实现拓扑排序的Kahn算法和DFS算法。您可以根据需要进行修改和调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

捕风捉你

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值