浅显易懂的拓扑排序

时间 2019-11-06

标签浅显易懂拓扑排序繁體版

原文原文链接

介绍

拓扑排序，不少人均可能据说可是不了解的一种算法。或许不少人只知道它是图论的一种排序，至于干什么的不清楚。又或许不少人可能还会认为它是一种啥排序。而实质上它是对有向图的顶点排成一个线性序列。html

至于定义，百科上是这么说的：java

对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中全部顶点排成一个线性序列，使得图中任意一对顶点u和v，若边<u,v>∈E(G)，则u在线性序列中出如今v以前。一般，这样的线性序列称为知足拓扑次序(Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序获得该集合上的一个全序，这个操做称之为拓扑排序。node

为何会有拓扑排序？拓扑排序有何做用？算法

举个例子，学习java系列的教程spring

代号	科目	学前需掌握
A1	javaSE
A2	html
A3	Jsp	A1，A2
A4	servlet	A1
A5	ssm	A3,A4
A6	springboot	A5

就好比学习java系类(部分)从java基础，到jsp/servlet，到ssm，到springboot，springcloud等是个按部就班且有依赖的过程。在jsp学习要首先掌握java基础和html基础。学习框架要掌握jsp/servlet和jdbc之类才行。那么，这个学习过程即构成一个拓扑序列。固然这个序列也不惟一，你能够对不关联的学科随意选择顺序(好比html和java能够随便先开始哪个。)数组

那上述序列能够简单表示为：springboot

其中五种均为能够选择的学习方案，对课程安排能够有参考做用，固然，五个都是拓扑序列。只是选择的策略不一样！框架

一些其余注意：jsp

DGA：有向无环图 AOV网：数据在顶点能够理解为面向对象 AOE网：数据在边上，能够理解为面向过程！学习

而咱们通俗一点的说法，就是按照某种规则将这个图的顶点取出来，这些顶点可以表示什么或者有什么联系。

规则：

图中每一个顶点只出现一次。
A在B前面，则不存在B在A前面的路径。(不能成环！！！！)
顶点的顺序是保证全部指向它的下个节点在被指节点前面！(例如A—>B—>C那么A必定在B前面，B必定在C前面)。因此，这个核心规则下只要知足便可，因此拓扑排序序列不必定惟一！

拓扑排序算法分析

正常步骤为(方法不必定惟一)：

从DGA图中找到一个没有前驱的顶点输出。(能够遍历，也能够用优先队列维护)
删除以这个点为起点的边。(它的指向的边删除，为了找到下个没有前驱的顶点)
重复上述，直到最后一个顶点被输出。若是还有顶点未被输出，则说明有环！

对于上图的简单序列，能够简单描述步骤为：

1：删除1或2输出
2：删除2或3以及对应边
3：删除3或者4以及对应边
3：重复以上规则步骤

这样就完成一次拓扑排序，获得一个拓扑序列，可是这个序列并不惟一！从过程当中也看到有不少选择方案，具体获得结果看你算法的设计了。但只要知足便是拓扑排序序列。

另外观察 1 2 4 3 6 5 7 9这个序列知足咱们所说的有关系的节点指向的在前面，被指向的在后面。若是彻底不要紧那不必定先后(例如1,2)

拓扑排序代码实现

对于拓扑排序，如何用代码实现呢？对于拓扑排序，虽然在上面详细介绍了思路和流程，也很通俗易懂。可是实际上代码的实现仍是很须要斟酌的，如何在空间和时间上可以获得较好的平衡且取得较好的效率？

首先要考虑存储。对于节点，首先他有联通点这么多属性。遇到稀疏矩阵仍是用邻接表比较好。由于一个节点的指向节点较少，用邻接矩阵较浪费资源。

另外，若是是1，2，3，4，5，6这样的序列求拓扑排序，咱们能够考虑用数组，可是若是遇到1，2，88，9999相似数据，能够考虑用map中转一下。那么，

咱们具体的代码思想为：

新建node类，包含节点数值和它的指向(这里直接用list集合替代链表了)
一个数组包含node(这里默认编号较集中)。初始化，添加每一个节点指向的时候同时被指的节点入度+1！(A—>C)那么C的入度+1；
扫描一遍全部node。将全部入度为0的点加入一个栈(队列)。
当栈(队列)不空的时候，抛出其中任意一个node(栈就是尾，队就是头，顺序无所谓，上面分析了只要同时入度为零能够随便选择顺序)。将node输出，而且node指向的全部元素入度减一。若是某个点的入度被减为0，那么就将它加入栈(队列)。
重复上述操做，直到栈为空。

这里主要是利用栈或者队列储存入度只为0的节点，只须要初次扫描表将入度为0的放入栈(队列)中。

这里你或许会问为何。
由于节点之间是有相关性的，一个节点若想入度为零，那么它的父节点(指向节点)确定在它为0前入度为0，拆除关联箭头。从父节点角度，它的此次拆除联系，可能致使被指向的入读为0，也可能不为0(还有其余节点指向儿子)

至于具体demo：

package 图论;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;

public class tuopu {
	static class node {
		int value;
		List<Integer> next;
		public node(int value) {
			this.value=value;
			next=new ArrayList<Integer>();
		}
		public void setnext(List<Integer>list) {
			this.next=list;
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		node []nodes=new node[9];//储存节点
		int a[]=new int[9];//储存入度
		List<Integer>list[]=new ArrayList[10];//临时空间，为了存储指向的集合
		for(int i=1;i<9;i++)
		{
			nodes[i]=new node(i);
			list[i]=new ArrayList<Integer>();
		}
		initmap(nodes,list,a);
		
		//主要流程
		//Queue<node>q1=new ArrayDeque<node>();
		Stack<node>s1=new Stack<node>();
		for(int i=1;i<9;i++)
		{
			//System.out.print(nodes[i].next.size()+" 55 ");
			//System.out.println(a[i]);
			if(a[i]==0) {s1.add(nodes[i]);}
			
		}
		while(!s1.isEmpty())
		{
			node n1=s1.pop();//抛出输出
		    
			System.out.print(n1.value+" ");
			
			List<Integer>next=n1.next;
			for(int i=0;i<next.size();i++)
			{
				a[next.get(i)]--;//入度减一
				if(a[next.get(i)]==0)//若是入度为0
				{
					s1.add(nodes[next.get(i)]);
				}
			}
		}
	}

	private static void initmap(node[] nodes, List<Integer>[] list, int[] a) {
		list[1].add(3);
		nodes[1].setnext(list[1]);
		a[3]++;
		list[2].add(4);list[2].add(6);
		nodes[2].setnext(list[2]);
		a[4]++;a[6]++;
		list[3].add(5);
		nodes[3].setnext(list[3]);
		a[5]++;
		list[4].add(5);list[4].add(6);
		nodes[4].setnext(list[4]);
		a[5]++;a[6]++;
		list[5].add(7);
		nodes[5].setnext(list[5]);
		a[7]++;
		list[6].add(8);
		nodes[6].setnext(list[6]);
		a[8]++;
		list[7].add(8);
		nodes[7].setnext(list[7]);
		a[8]++;
		
	}
}

复制代码

输出结果

2 4 6 1 3 5 7 8

固然，上面说过用栈和队列均可以！若是使用队列就会获得 1 2 3 4 5 6 7 8的拓扑序列

至于图的构造，由于没有条件可能效率并不高，算法也可能不太完美，若有优化错误还请大佬指正！

另外，还请各位大佬动动小手 点赞、关注(bigsai) 一波啊！谢谢🙏