Java数据结构之有向图的拓扑排序详解

目录

前言拓扑排序介绍检测有向图中的环

实现思路API设计代码实现

基于深度优先的顶点排序

实现思路API设计代码实现

拓扑排序

API设计代码实现测试验证

前言

在现实生活中，我们经常会同一时间接到很多任务去完成，但是这些任务的完成是有先后次序的。以我们学习java
学科为例，我们需要学习很多知识，但是这些知识在学习的过程中是需要按照先后次序来完成的。从java基础，到
jsp/servlet，到ssm，到springboot等是个循序渐进且有依赖的过程。在学习jsp前要首先掌握java基础和html基
础，学习ssm框架前要掌握jsp/servlet之类才行。

为了简化问题，我们使用整数为顶点编号的标准模型来表示这个案例：

此时如果某个同要学习这些课程，就需要指定出一个学习的方案，我们只需要对图中的顶点进行排序，让它转换为一个线性序列，就可以解决问题，这时就需要用到一种叫拓扑排序的算法。

拓扑排序介绍

给定一副有向图，将所有的顶点排序，使得所有的有向边均从排在前面的元素指向排在后面的元素，此时就可以明确的表示出每个顶点的优先级。下列是一副拓扑排序后的示意图:

检测有向图中的环

如果学习x课程前必须先学习y课程，学习y课程前必须先学习z课程，学习z课程前必须先学习x课程，那么一定是有问题了，我们就没有办法学习了，因为这三个条件没有办法同时满足。其实这三门课程x、y、z的条件组成了一个环：

因此，如果我们要使用拓扑排序解决优先级问题，首先得保证图中没有环的存在。


实现思路

在API中添加了onStack[] 布尔数组，索引为图的顶点，当我们深度搜索时：

在如果当前顶点正在搜索，则把对应的onStack数组中的值改为true，标识进栈；如果当前顶点搜索完毕，则把对应的onStack数组中的值改为false，标识出栈；如果即将要搜索某个顶点，但该顶点已经在栈中，则图中有环；

API设计

类名	DirectedCycle
成员变量	1.private boolean[] marked: 索引代表顶点，值表示当前顶点是否已经被搜索2.private boolean hasCycle: 记录图中是否有环3.private boolean[] onStack:索引代表顶点，使用栈的思想，记录当前顶点有没有已经处于正在搜索的有向路径上
构造方法	DirectedCycle(Digraph G)：创建一个检测环对象，检测图G中是否有环
成员方法	1.private void dfs(Digraph G,int v)：基于深度优先搜索，检测图G中是否有环2.public boolean hasCycle():判断图中是否有环

代码实现

1. /**
2. * 有向图是否存在环
3. *
4. * @author alvin
5. * @date 2022/11/2
6. * @since 1.0
7. **/
8. public class DirectedCycle {
9.     //索引代表顶点，值表示当前顶点是否已经被搜索
10.     private boolean[] marked;
11.     //记录图中是否有环
12.     private boolean hasCycle;
13.     //索引代表顶点，使用栈的思想，记录当前顶点有没有已经处于正在搜索的有向路径上
14.     private boolean[] onStack;
16.     //创建一个检测环对象，检测图G中是否有环
17.     public DirectedCycle(Digraph G){
18.         //初始化marked数组
19.         this.marked = new boolean[G.V()];
20.         //初始化hasCycle
21.         this.hasCycle = false;
22.         //初始化onStack数组
23.         this.onStack = new boolean[G.V()];
25.         //找到图中每一个顶点，让每一个顶点作为入口，调用一次dfs进行搜索
26.         for (int v =0; v<G.V();v++){
27.             //判断如果当前顶点还没有搜索过，则调用dfs进行搜索
28.             if (!marked[v]){
29.                 dfs(G,v);
30.             }
31.         }
32.     }
34.     //基于深度优先搜索，检测图G中是否有环
35.     private void dfs(Digraph G, int v){
36.         //把顶点v表示为已搜索
37.         marked[v] = true;
38.         //把当前顶点进栈
39.         onStack[v] = true;
41.         for(Integer w: G.adj(v)) {
42.             //判断如果当前顶点w没有被搜索过，则继续递归调用dfs方法完成深度优先搜索
43.             if(!marked[w]) {
44.                 dfs(G, w);
45.             }
47.             //判断当前顶点w是否已经在栈中，如果已经在栈中，证明当前顶点之前处于正在搜索的状态，那么现在又要搜索一次，证明检测到环了
48.             if (onStack[w]){
49.                 hasCycle = true;
50.                 return;
51.             }
52.         }
53.         //把当前顶点出栈
54.         onStack[v] = false;
55.     }
57.     //判断当前有向图G中是否有环
58.     public boolean hasCycle(){
59.         return hasCycle;
60.     }
61. }

复制代码

基于深度优先的顶点排序

实现思路

如果要把图中的顶点生成线性序列其实是一件非常简单的事，之前我们学习并使用了多次深度优先搜索，我们会发现其实深度优先搜索有一个特点，那就是在一个连通子图上，每个顶点只会被搜索一次，如果我们能在深度优先搜索的基础上，添加一行代码，只需要将搜索的顶点放入到线性序列的数据结构中，我们就能完成这件事。
我们添加了一个栈reversePost用来存储顶点，当我们深度搜索图时，每搜索完毕一个顶点，把该顶点放入到reversePost中，这样就可以实现顶点排序。

API设计

类名	DepthFirstOrder
成员变量	1.private boolean[] marked: 索引代表顶点，值表示当前顶点是否已经被搜索2.private Stack reversePost: 使用栈，存储顶点序列
构造方法	DepthFirstOrder(Digraph G)：创建一个顶点排序对象，生成顶点线性序列；
成员方法	1.private void dfs(Digraph G,int v)：基于深度优先搜索，生成顶点线性序列2.public Stack reversePost():获取顶点线性序列

代码实现

1. /**
2. * 顶点排序
3. *
4. * @author alvin
5. * @date 2022/11/2
6. * @since 1.0
7. **/
8. public class DepthFirstOrder {
9.     //索引代表顶点，值表示当前顶点是否已经被搜索
10.     private boolean[] marked;
11.     //使用栈，存储顶点序列
12.     private Stack<Integer> reversePost;
14.     //创建一个检测环对象，检测图G中是否有环
15.     public DepthFirstOrder(Digraph G){
16.         //初始化marked数组
17.         this.marked = new boolean[G.V()];
18.         //初始化reversePost栈
19.         this.reversePost = new Stack<>();
21.         //遍历图中的每一个顶点，让每个顶点作为入口，完成一次深度优先搜索
22.         for (int v = 0;v<G.V();v++){
23.             if (!marked[v]){
24.                 dfs(G,v);
25.             }
26.         }
27.     }
29.     //基于深度优先搜索，把顶点排序
30.     private void dfs(Digraph G, int v){
31.         //标记当前v已经被搜索
32.         marked[v] = true;
33.         //通过循环深度搜索顶点v
34.         for (Integer w : G.adj(v)) {
35.             //如果当前顶点w没有搜索，则递归调用dfs进行搜索
36.             if (!marked[w]){
37.                 dfs(G,w);
38.             }
39.         }
40.         //让顶点v进栈
41.         reversePost.push(v);
42.     }
44.     //获取顶点线性序列
45.     public Stack<Integer>  reversePost(){
46.         return reversePost;
47.     }
48. }

复制代码

拓扑排序

前面已经实现了环的检测以及顶点排序，那么拓扑排序就很简单了，基于一幅图，先检测有没有环，如果没有环，则调用顶点排序即可。
API设计

类名	TopoLogical
成员变量	1.private Stack order: 顶点的拓扑排序
构造方法	TopoLogical(Digraph G)：构造拓扑排序对象
成员方法	1.public boolean isCycle()：判断图G是否有环2.public Stack order():获取拓扑排序的所有顶点

代码实现

1. /**
2. * 拓扑排序
3. *
4. * @author alvin
5. * @date 2022/11/2
6. * @since 1.0
7. **/
8. public class TopoLogical {
9.     //顶点的拓扑排序
10.     private Stack<Integer> order;
12.     //构造拓扑排序对象
13.     public TopoLogical(Digraph G) {
14.         //创建一个检测有向环的对象
15.         DirectedCycle cycle = new DirectedCycle(G);
16.         //判断G图中有没有环，如果没有环，则进行顶点排序：创建一个顶点排序对象
17.         if (!cycle.hasCycle()){
18.             DepthFirstOrder depthFirstOrder = new DepthFirstOrder(G);
19.             order = depthFirstOrder.reversePost();
20.         }
21.     }
23.     //判断图G是否有环
24.     private boolean isCycle(){
25.         return order==null;
26.     }
28.     //获取拓扑排序的所有顶点
29.     public Stack<Integer> order(){
30.         return order;
31.     }
32. }

复制代码

测试验证

1. public class TopoLogicalTest {
3.     @Test
4.     public void test() {
5.         //准备有向图
6.         Digraph digraph = new Digraph(6);
7.         digraph.addEdge(0,2);
8.         digraph.addEdge(0,3);
9.         digraph.addEdge(2,4);
10.         digraph.addEdge(3,4);
11.         digraph.addEdge(4,5);
12.         digraph.addEdge(1,3);
14.         //通过TopoLogical对象堆有向图中的顶点进行排序
15.         TopoLogical topoLogical = new TopoLogical(digraph);
17.         //获取顶点的线性序列进行打印
18.         Stack<Integer> order = topoLogical.order();
19.         StringBuilder sb = new StringBuilder();
20.         while (order.size() != 0) {
21.             sb.append(order.pop()+"->");
22.         };
23.         String str = sb.toString();
24.         int index = str.lastIndexOf("->");
25.         str = str.substring(0,index);
26.         System.out.println(str);
27.     }
28. }

复制代码

到此这篇关于Java数据结构之有向图的拓扑排序详解的文章就介绍到这了,更多相关Java有向图 拓扑排序内容请搜索中国红客联盟以前的文章或继续浏览下面的相关文章希望大家以后多多支持中国红客联盟！