无前趋的顶点优先的拓扑排序方法(JAVA)(转载http://128kj.iteye.com/blog/1706968)

无前趋的顶点优先的拓扑排序方法

该方法的每一步总是输出当前无前趋(即人度为零)的顶点，其抽象算法可描述为： 
    NonPreFirstTopSort(G){//优先输出无前趋的顶点 
      while(G中有人度为0的顶点)do{ 
       从G中选择一个人度为0的顶点v且输出之； 
       从G中删去v及其所有出边； 
       } 
      if(输出的顶点数目<|V(G)|) 
        //若此条件不成立，则表示所有顶点均已输出，排序成功。 
        Error("G中存在有向环，排序失败！")； 
     }

1. import java.util.Arrays;
2. import java.util.List;
3. import java.util.ArrayList;
4. import java.util.Stack;
5. public class Graph {
6. int vertexNum;   //图的顶点数
7. ArrayList<ArrayList<Integer>>  table; //图的邻接表，table.get(i)存放与i邻接的顶点
8. Stack<Integer> stack;  //存放入度为0的顶点
9. int[] result;   //拓朴排序的结果
10. int[] in;// 入度,in[i]表示顶点i的入度
11. /**
12. *
13. * 构造一个图
14. *
15. * @param num
16. * 图的顶点数
17. *
18. */
19. public Graph(int num) {
20. vertexNum = num;
21. table = new ArrayList<ArrayList<Integer>> (vertexNum);
22. ;i<vertexNum;i++)
23. table.add(new ArrayList<Integer>());
24. stack = new Stack<Integer>();
25. result = new int[vertexNum];
26. in = new int[vertexNum];
27. }
28. /**
29. * 向图中添加无向边
30. *
31. * @param I
32. *         边的一个顶点
33. * @param J
34. *         边的另一个顶点
35. * @return 是否添加成功
36. */
37. public boolean addEdge(int I, int J) {
38. /**
39. * 判断用户输入的是否是一个顶点，如果是，则返回flase,添加不成功
40. */
41. if (J == I) {
42. return false;
43. }
44. /**
45. * 判断所输入的顶点值是否在图所顶点范围值内，如果不在，则提示顶点不存在
46. *
47. */
48. ) {
49. /**
50. *
51. * 判断边是否存在
52. */
53. if (isEdgeExists(I, J)) {
54. return false;
55. }
56. /**
57. * 添加边，将孤头的入度加1
58. */
59. table.get(I).add(J);
60. in[J]++;
61. return true;
62. }
63. return false;
64. }
65. /**
66. * 判断有向边是否存在
67. *
68. * @param i
69. *            要查询的有向边的一个孤尾
70. * @param j
71. *            要查询的有向边的另一个孤头
72. * @return 边是否存在，false:不存在，true:存在
73. */
74. public boolean isEdgeExists(int i, int j) {
75. /**
76. * 判断所输入的顶点值是否在图所顶点范围值内，如果不在，则提示顶点不存在
77. *
78. */
79. ) {
80. if (i == j) {
81. return false;
82. }
83. /**
84. * 判断i的邻接结点集是否为空
85. */
86. if (table.get(i) == null) {
87. return false;
88. }
89. /**
90. * 判断这条边是否存在，如果存在，则提示边已经存在
91. */
92. ; q < table.get(i).size(); q++) {
93. if (((Integer) table.get(i).get(q)).intValue() == j) {
94. System.out.println("顶点" +i+"和"+"顶点"+j+ "这两点之间存在边");
95. return true;
96. }
97. }
98. }
99. return false;
100. }
101. public void TopSort() {   //无前趋的顶点优先的拓扑排序方法
102. ; i < vertexNum; i++)   //无前趋的顶点入栈
103. )
104. stack.push(i);
105. ;
106. while (!stack.isEmpty()) {
107. result[k] = (Integer) stack.pop();   //弹出一个无前趋的顶点,并放入拓扑排序的结果集
108. if (table.get(result[k]) != null) {  //这个顶点的邻接表非空
109. ; j < table.get(result[k]).size(); j++) {
110. int temp = (Integer) table.get(result[k]).get(j);
111. //对result[k]每一个邻接点进行入度减1操作
112. ) { //如果temp的入度为0，进栈.
113. stack.push(temp);
114. }
115. }
116. }
117. k++;
118. }
119. if (k < vertexNum) {
120. System.out.println("有回路");
121. );
122. }
123. }
124. public int[] getResult() {
125. return result;
126. }
127. }

测试： 

1. import java.util.List;
2. public class GraphTest {
3. public static  void main(String args[]){
4. );
5. );
6. );
7. );
8. );
9. );
10. );
11. );
12. );
13. );
14. graph.TopSort();
15. int[] list = graph.getResult();
16. System.out.println("拓扑排序的结果为：");
17. for(int i : list){
18. System.out.print(i+"        ");
19. }
20. }
21. }

运行: 
C:\>java   GraphTest 
拓扑排序的结果为： 
4        2        1        3        5        0

下载源码

• graphtoposort.zip (1.8 KB)
• 下载次数: 0

• 查看图片附件