Java 数据结构 - 拓扑排序

Java 实现图的拓扑排序

1. 引言

拓扑排序是一种对有向无环图（DAG）中的顶点进行排序的算法。它的主要应用场景包括任务调度、编译依赖分析、数据处理工作流等。本文将深入探讨拓扑排序的概念、实现方法以及在 Java 中的具体应用。

2. 拓扑排序的基本概念

2.1 定义

拓扑排序是将 DAG 中的所有顶点排成一个线性序列，使得图中任何一对顶点 u 和 v，若存在一条从 u 到 v 的路径，则在序列中 u 一定在 v 的前面。

2.2 性质

拓扑排序的结果可能不唯一。
如果图中存在环，则无法进行拓扑排序。
拓扑排序只能应用于有向无环图。

3. 实现方法

有两种常用的拓扑排序算法：Kahn 算法和深度优先搜索（DFS）算法。

3.1 Kahn 算法

Kahn 算法的基本思想是：

找出图中所有入度为 0 的顶点，将它们加入队列。
从队列中取出一个顶点，将其加入结果列表，并将其所有邻接顶点的入度减 1。
如果某个邻接顶点的入度变为 0，则将其加入队列。
重复步骤 2 和 3，直到队列为空。

3.2 DFS 算法

DFS 算法的基本思想是：

对图进行深度优先搜索。
在搜索的过程中，将已经访问过的顶点标记为已访问。
当一个顶点的所有邻接顶点都已经访问过，将该顶点加入结果列表的开头。
最终得到的结果列表即为拓扑排序的逆序。

4. Java 实现

下面我们将使用 Kahn 算法和 DFS 算法分别实现拓扑排序。

4.1 Kahn 算法实现

import java.util.*;

public class TopologicalSortKahn {
    private int V;  // 顶点数
    private List<List<Integer>> adj;  // 邻接表

    public TopologicalSortKahn(int v) {
        V = v;
        adj = new ArrayList<>(V);
        for (int i = 0; i < V; i++) {
            adj.add(new ArrayList<>());
        }
    }

    // 添加边
    public void addEdge(int u, int v) {
        adj.get(u).add(v);
    }

    // Kahn 算法实现拓扑排序
    public List<Integer> topologicalSort() {
        int[] inDegree = new int[V];  // 记录每个顶点的入度
        List<Integer> result = new ArrayList<>();

        // 计算每个顶点的入度
        for (int i = 0; i < V; i++) {
            for (int node : adj.get(i)) {
                inDegree[node]++;
            }
        }

        // 将所有入度为 0 的顶点加入队列
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < V; i++) {
            if (inDegree[i] == 0) {
                queue.offer(i);
            }
        }

        while (!queue.isEmpty()) {
            int u = queue.poll();
            result.add(u);

            // 将所有 u 指向的顶点的入度减 1，并将入度为 0 的顶点加入队列
            for (int v : adj.get(u)) {
                if (--inDegree[v] == 0) {
                    queue.offer(v);
                }
            }
        }

        // 如果结果中的顶点数小于图中的顶点数，说明图中有环
        if (result.size() != V) {
            System.out.println("图中存在环，无法进行拓扑排序");
            return new ArrayList<>();
        }

        return result;
    }

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

        List<Integer> order = g.topologicalSort();
        System.out.println("拓扑排序结果：" + order);
    }
}

4.2 DFS 算法实现

import java.util.*;

public class TopologicalSortDFS {
    private int V;  // 顶点数
    private List<List<Integer>> adj;  // 邻接表

    public TopologicalSortDFS(int v) {
        V = v;
        adj = new ArrayList<>(V);
        for (int i = 0; i < V; i++) {
            adj.add(new ArrayList<>());
        }
    }

    // 添加边
    public void addEdge(int u, int v) {
        adj.get(u).add(v);
    }

    // DFS 算法实现拓扑排序
    public List<Integer> topologicalSort() {
        Stack<Integer> stack = new Stack<>();
        boolean[] visited = new boolean[V];

        for (int i = 0; i < V; i++) {
            if (!visited[i]) {
                dfsUtil(i, visited, stack);
            }
        }

        List<Integer> result = new ArrayList<>();
        while (!stack.isEmpty()) {
            result.add(stack.pop());
        }
        return result;
    }

    private void dfsUtil(int v, boolean[] visited, Stack<Integer> stack) {
        visited[v] = true;

        for (int i : adj.get(v)) {
            if (!visited[i]) {
                dfsUtil(i, visited, stack);
            }
        }

        stack.push(v);
    }

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

        List<Integer> order = g.topologicalSort();
        System.out.println("拓扑排序结果：" + order);
    }
}

5. 算法比较

特性	Kahn 算法	DFS 算法
时间复杂度	O(V + E)	O(V + E)
空间复杂度	O(V)	O(V)
实现难度	相对简单	相对复杂
检测环	容易	需要额外处理
适用场景	需要同时检测环	递归实现更自然

6. 应用场景

任务调度：确定具有依赖关系的任务的执行顺序。
编译依赖分析：确定编译顺序，解决模块间的依赖关系。
数据处理工作流：在数据处理管道中确定处理步骤的顺序。
课程安排：根据课程先修关系安排学习顺序。
项目管理：在项目规划中确定任务的执行顺序。

7. 注意事项

在实际应用中，需要注意图中是否存在环。如果存在环，拓扑排序将无法完成。
拓扑排序的结果可能不唯一，不同的算法或实现可能会产生不同的有效排序。
在处理大规模图时，需要考虑内存使用和性能优化。

8. 总结

拓扑排序是一种在有向无环图中寻找顶点线性序列的算法，它在许多实际应用中都有重要作用。Kahn 算法和 DFS 算法是两种常用的实现方法，各有特点。在实际应用中，应根据具体需求选择合适的算法，并注意处理可能存在的环和大规模数据的情况。掌握拓扑排序算法对于解决依赖关系问题和优化工作流程至关重要。

posted @ 2024-08-01 22:25 KenWan 阅读(123) 评论(0) 收藏举报

刷新页面返回顶部

KenWan