拓扑排序(Topologicalsort)之Java实现

目录(?)[+]

拓扑排序算法介绍

拓扑排序解决的是一系列相互依赖的事件的排序问题，比如Ant中有很多的Task，而某些Task依赖于另外的Task，编译之前需要清理空间，打包之前要先编译，但其它一些Task处理顺序可以调换(是无所谓前后，不是并行), 如何安排Task的执行顺序就可以用拓扑排序解决。熟悉Java的朋友应该都知道Spring，一个非常优秀的解决组件(Bean)依赖的框架，组件之间可能有依赖关系，也可能没有关系，如何按顺序创建组件也是相同的问题。本文使用的是图搜索算法里面的深度优先排序算法解决问题。需要特别指出的是拓扑排序算法的结果很可能有多个(不依赖的可以调换位置)，而算法也可以有多种，深度优先排序算法只是其中一种而已。拓扑排序为线性排序，效率为O(|V|+|E|)，其中|V|表示顶点数，|E|表示边的数量。

拓扑排序算法Java实现

图像(Graph)的Java抽象实现

图可以抽象为顶点和边，分为有向图和无向图，拓扑排序里面使用的事有向图(依赖)，本文中图的边用相邻链表方法表示。每一个顶点有名字(name)，颜色(color, 搜索时候用来标记处理状态)，父节点(parent，搜索结束可以得到多棵树)，开始处理时间(discover)，结束处理时间(finish)。请注意Vertex类override了equals和hash方法。具体代码如下:

[java] view plain copy

1. enumColor{
2. WHITE,GRAY,BLACK
3. }
5. staticclassVertex{
6. privateStringname;
7. privateColorcolor;
8. privateVertexparent;
9. privateintdiscover;
10. privateintfinish;
12. publicVertex(Stringname){
13. this.name=name;
14. this.color=Color.WHITE;
15. }
17. publicStringgetName(){
18. returnname;
19. }
21. publicvoidsetName(Stringname){
22. this.name=name;
23. }
25. publicColorgetColor(){
26. returncolor;
27. }
29. publicvoidsetColor(Colorcolor){
30. this.color=color;
31. }
33. publicVertexgetParent(){
34. returnparent;
35. }
37. publicvoidsetParent(Vertexparent){
38. this.parent=parent;
39. }
41. publicintgetDiscover(){
42. returndiscover;
43. }
45. publicvoidsetDiscover(intdiscover){
46. this.discover=discover;
47. }
49. publicintgetFinish(){
50. returnfinish;
51. }
53. publicvoidsetFinish(intfinish){
54. this.finish=finish;
55. }
57. @Override
58. publicinthashCode(){
59. finalintprime=31;
60. intresult=1;
61. result=prime*result+((name==null)?0:name.hashCode());
62. returnresult;
63. }
65. @Override
66. publicbooleanequals(Objectobj){
67. if(this==obj)
68. returntrue;
69. if(obj==null)
70. returnfalse;
71. if(getClass()!=obj.getClass())
72. returnfalse;
73. Vertexother=(Vertex)obj;
74. if(name==null){
75. if(other.name!=null)
76. returnfalse;
77. }elseif(!name.equals(other.name))
78. returnfalse;
79. returntrue;
80. }
81. }
83. staticclassGraph{
84. privateSet<Vertex>vertexSet=newHashSet<Vertex>();
85. //相邻的节点
86. privateMap<Vertex,Vertex[]>adjacencys=newHashMap<Vertex,Vertex[]>();
88. publicSet<Vertex>getVertexSet(){
89. returnvertexSet;
90. }
92. publicvoidsetVertexSet(Set<Vertex>vertexSet){
93. this.vertexSet=vertexSet;
94. }
96. publicMap<Vertex,Vertex[]>getAdjacencys(){
97. returnadjacencys;
98. }
100. publicvoidsetAdjacencys(Map<Vertex,Vertex[]>adjacencys){
101. this.adjacencys=adjacencys;
102. }
103. }

深度优先算法

遍历图的顶点，如果当前顶点还没有处理过(color为white)，就处理该节点(visitVertex)，处理节点的算法(visitVertex)也不难，时间维度加1，当前节点颜色置为gray(开始处理)，然后优先处理其子节点(深度优先)，结束之后时间维度加1，当前节点颜色置为black(结束处理)。此时就可以把该节点放到目标链表里面了(最终排好序的链表)。由于Java里面Integer值不可变(Immutable)，只能选择全局变量或者自己实现时间计数器，本文选择后者(TimeRecorder)。代码如下:

[java] view plain copy

1. staticclassTimeRecorder{
2. privateinttime=0;
4. publicintgetTime(){
5. returntime;
6. }
8. publicvoidsetTime(inttime){
9. this.time=time;
10. }
11. }
13. publicstaticVertex[]topologicalSort(Graphgraph){
14. Set<Vertex>vertexSet=graph.getVertexSet();
15. if(vertexSet.size()<2){
16. returnvertexSet.toArray(newVertex[0]);
17. }
19. LinkedList<Vertex>sortedList=newLinkedList<Vertex>();
20. TimeRecorderrecorder=newTimeRecorder();
22. for(Vertexvertex:vertexSet){
23. if(vertex.color==Color.WHITE){
24. visitVertex(graph,vertex,recorder,sortedList);
25. }
26. }
28. returnsortedList.toArray(newVertex[0]);
29. }
31. /**
32. *深度优先搜索(DepthFirstSearch)
33. */
34. publicstaticvoidvisitVertex(Graphgraph,Vertexvertex,
35. TimeRecorderrecorder,LinkedList<Vertex>sortedList){
36. recorder.time+=1;
37. vertex.color=Color.GRAY;
38. vertex.discover=recorder.time;
40. Map<Vertex,Vertex[]>edgeMap=graph.getAdjacencys();
41. Vertex[]adjacencys=edgeMap.get(vertex);
42. if(adjacencys!=null&&adjacencys.length>0){
43. for(Vertexadjacency:adjacencys){
44. if(adjacency.color==Color.WHITE){
45. adjacency.parent=vertex;
46. visitVertex(graph,adjacency,recorder,sortedList);
47. }
48. }
49. }
51. recorder.time+=1;
52. vertex.color=Color.BLACK;
53. vertex.finish=recorder.time;
54. sortedList.addLast(vertex);
55. }

构建图以及测试

我们的测试图例如下(箭头的方向表示的是依赖):

为了打印排好序的结果，实现了printVertex函数。测试代码如下:

[java] view plain copy

1. publicstaticvoidmain(String[]args){
2. Graphgraph=newGraph();
3. Set<Vertex>vertexSet=graph.getVertexSet();
4. Map<Vertex,Vertex[]>edgeMap=graph.getAdjacencys();
6. VertextwoVertex=newVertex("2");
7. VertexthreeVertex=newVertex("3");
8. VertexfiveVertex=newVertex("5");
9. VertexsevenVertex=newVertex("7");
10. VertexeightVertex=newVertex("8");
11. VertexnineVertex=newVertex("9");
12. VertextenVertex=newVertex("10");
13. VertexelevenVertex=newVertex("11");
15. vertexSet.add(twoVertex);
16. vertexSet.add(threeVertex);
17. vertexSet.add(fiveVertex);
18. vertexSet.add(sevenVertex);
19. vertexSet.add(eightVertex);
20. vertexSet.add(nineVertex);
21. vertexSet.add(tenVertex);
22. vertexSet.add(elevenVertex);
24. edgeMap.put(twoVertex,newVertex[]{elevenVertex});
25. edgeMap.put(nineVertex,newVertex[]{elevenVertex,eightVertex});
26. edgeMap.put(tenVertex,newVertex[]{elevenVertex,threeVertex});
27. edgeMap.put(elevenVertex,newVertex[]{sevenVertex,fiveVertex});
28. edgeMap.put(eightVertex,newVertex[]{sevenVertex,threeVertex});
30. Vertex[]sortedVertexs=topologicalSort(graph);
31. printVertex(sortedVertexs);
32. }
34. publicstaticvoidprintVertex(Vertex[]Vertexs){
35. for(Vertexvertex:Vertexs){
36. System.out.println(vertex.getName()+"discovertime:"
37. +vertex.getDiscover()+"finishtime:"
38. +vertex.getFinish());
39. }
40. }

后记

以上Java实现参考的是算法导论的深度优先排序算法。如果想对排序的精确度有更好的控制，可以在Vertex类中加一个priority属性。每一次遍历之前都针对顶点以priority即可。参考链接:维基百科

拓扑排序算法介绍

拓扑排序解决的是一系列相互依赖的事件的排序问题，比如Ant中有很多的Task，而某些Task依赖于另外的Task，编译之前需要清理空间，打包之前要先编译，但其它一些Task处理顺序可以调换(是无所谓前后，不是并行), 如何安排Task的执行顺序就可以用拓扑排序解决。熟悉Java的朋友应该都知道Spring，一个非常优秀的解决组件(Bean)依赖的框架，组件之间可能有依赖关系，也可能没有关系，如何按顺序创建组件也是相同的问题。本文使用的是图搜索算法里面的深度优先排序算法解决问题。需要特别指出的是拓扑排序算法的结果很可能有多个(不依赖的可以调换位置)，而算法也可以有多种，深度优先排序算法只是其中一种而已。拓扑排序为线性排序，效率为O(|V|+|E|)，其中|V|表示顶点数，|E|表示边的数量。

拓扑排序算法Java实现

图像(Graph)的Java抽象实现

图可以抽象为顶点和边，分为有向图和无向图，拓扑排序里面使用的事有向图(依赖)，本文中图的边用相邻链表方法表示。每一个顶点有名字(name)，颜色(color, 搜索时候用来标记处理状态)，父节点(parent，搜索结束可以得到多棵树)，开始处理时间(discover)，结束处理时间(finish)。请注意Vertex类override了equals和hash方法。具体代码如下:

[java] view plain copy

1. enumColor{
2. WHITE,GRAY,BLACK
3. }
5. staticclassVertex{
6. privateStringname;
7. privateColorcolor;
8. privateVertexparent;
9. privateintdiscover;
10. privateintfinish;
12. publicVertex(Stringname){
13. this.name=name;
14. this.color=Color.WHITE;
15. }
17. publicStringgetName(){
18. returnname;
19. }
21. publicvoidsetName(Stringname){
22. this.name=name;
23. }
25. publicColorgetColor(){
26. returncolor;
27. }
29. publicvoidsetColor(Colorcolor){
30. this.color=color;
31. }
33. publicVertexgetParent(){
34. returnparent;
35. }
37. publicvoidsetParent(Vertexparent){
38. this.parent=parent;
39. }
41. publicintgetDiscover(){
42. returndiscover;
43. }
45. publicvoidsetDiscover(intdiscover){
46. this.discover=discover;
47. }
49. publicintgetFinish(){
50. returnfinish;
51. }
53. publicvoidsetFinish(intfinish){
54. this.finish=finish;
55. }
57. @Override
58. publicinthashCode(){
59. finalintprime=31;
60. intresult=1;
61. result=prime*result+((name==null)?0:name.hashCode());
62. returnresult;
63. }
65. @Override
66. publicbooleanequals(Objectobj){
67. if(this==obj)
68. returntrue;
69. if(obj==null)
70. returnfalse;
71. if(getClass()!=obj.getClass())
72. returnfalse;
73. Vertexother=(Vertex)obj;
74. if(name==null){
75. if(other.name!=null)
76. returnfalse;
77. }elseif(!name.equals(other.name))
78. returnfalse;
79. returntrue;
80. }
81. }
83. staticclassGraph{
84. privateSet<Vertex>vertexSet=newHashSet<Vertex>();
85. //相邻的节点
86. privateMap<Vertex,Vertex[]>adjacencys=newHashMap<Vertex,Vertex[]>();
88. publicSet<Vertex>getVertexSet(){
89. returnvertexSet;
90. }
92. publicvoidsetVertexSet(Set<Vertex>vertexSet){
93. this.vertexSet=vertexSet;
94. }
96. publicMap<Vertex,Vertex[]>getAdjacencys(){
97. returnadjacencys;
98. }
100. publicvoidsetAdjacencys(Map<Vertex,Vertex[]>adjacencys){
101. this.adjacencys=adjacencys;
102. }
103. }

深度优先算法

遍历图的顶点，如果当前顶点还没有处理过(color为white)，就处理该节点(visitVertex)，处理节点的算法(visitVertex)也不难，时间维度加1，当前节点颜色置为gray(开始处理)，然后优先处理其子节点(深度优先)，结束之后时间维度加1，当前节点颜色置为black(结束处理)。此时就可以把该节点放到目标链表里面了(最终排好序的链表)。由于Java里面Integer值不可变(Immutable)，只能选择全局变量或者自己实现时间计数器，本文选择后者(TimeRecorder)。代码如下:

[java] view plain copy

1. staticclassTimeRecorder{
2. privateinttime=0;
4. publicintgetTime(){
5. returntime;
6. }
8. publicvoidsetTime(inttime){
9. this.time=time;
10. }
11. }
13. publicstaticVertex[]topologicalSort(Graphgraph){
14. Set<Vertex>vertexSet=graph.getVertexSet();
15. if(vertexSet.size()<2){
16. returnvertexSet.toArray(newVertex[0]);
17. }
19. LinkedList<Vertex>sortedList=newLinkedList<Vertex>();
20. TimeRecorderrecorder=newTimeRecorder();
22. for(Vertexvertex:vertexSet){
23. if(vertex.color==Color.WHITE){
24. visitVertex(graph,vertex,recorder,sortedList);
25. }
26. }
28. returnsortedList.toArray(newVertex[0]);
29. }
31. /**
32. *深度优先搜索(DepthFirstSearch)
33. */
34. publicstaticvoidvisitVertex(Graphgraph,Vertexvertex,
35. TimeRecorderrecorder,LinkedList<Vertex>sortedList){
36. recorder.time+=1;
37. vertex.color=Color.GRAY;
38. vertex.discover=recorder.time;
40. Map<Vertex,Vertex[]>edgeMap=graph.getAdjacencys();
41. Vertex[]adjacencys=edgeMap.get(vertex);
42. if(adjacencys!=null&&adjacencys.length>0){
43. for(Vertexadjacency:adjacencys){
44. if(adjacency.color==Color.WHITE){
45. adjacency.parent=vertex;
46. visitVertex(graph,adjacency,recorder,sortedList);
47. }
48. }
49. }
51. recorder.time+=1;
52. vertex.color=Color.BLACK;
53. vertex.finish=recorder.time;
54. sortedList.addLast(vertex);
55. }

构建图以及测试

我们的测试图例如下(箭头的方向表示的是依赖):

为了打印排好序的结果，实现了printVertex函数。测试代码如下:

[java] view plain copy

1. publicstaticvoidmain(String[]args){
2. Graphgraph=newGraph();
3. Set<Vertex>vertexSet=graph.getVertexSet();
4. Map<Vertex,Vertex[]>edgeMap=graph.getAdjacencys();
6. VertextwoVertex=newVertex("2");
7. VertexthreeVertex=newVertex("3");
8. VertexfiveVertex=newVertex("5");
9. VertexsevenVertex=newVertex("7");
10. VertexeightVertex=newVertex("8");
11. VertexnineVertex=newVertex("9");
12. VertextenVertex=newVertex("10");
13. VertexelevenVertex=newVertex("11");
15. vertexSet.add(twoVertex);
16. vertexSet.add(threeVertex);
17. vertexSet.add(fiveVertex);
18. vertexSet.add(sevenVertex);
19. vertexSet.add(eightVertex);
20. vertexSet.add(nineVertex);
21. vertexSet.add(tenVertex);
22. vertexSet.add(elevenVertex);
24. edgeMap.put(twoVertex,newVertex[]{elevenVertex});
25. edgeMap.put(nineVertex,newVertex[]{elevenVertex,eightVertex});
26. edgeMap.put(tenVertex,newVertex[]{elevenVertex,threeVertex});
27. edgeMap.put(elevenVertex,newVertex[]{sevenVertex,fiveVertex});
28. edgeMap.put(eightVertex,newVertex[]{sevenVertex,threeVertex});
30. Vertex[]sortedVertexs=topologicalSort(graph);
31. printVertex(sortedVertexs);
32. }
34. publicstaticvoidprintVertex(Vertex[]Vertexs){
35. for(Vertexvertex:Vertexs){
36. System.out.println(vertex.getName()+"discovertime:"
37. +vertex.getDiscover()+"finishtime:"
38. +vertex.getFinish());
39. }
40. }

后记

以上Java实现参考的是算法导论的深度优先排序算法。如果想对排序的精确度有更好的控制，可以在Vertex类中加一个priority属性。每一次遍历之前都针对顶点以priority即可。参考链接:维基百科