java 图的拓扑排序（利用Vector存储）

Stack类：

Java代码  

1. package com.javaeye.rsrt;  
2.   
3. /** 
4.  * 栈，遵循先进后出的原则，用来保存元素 
5.  *  
6.  * @author nishiting 
7.  *  
8.  */  
9. public class Stack {  
10.   
11.     private int[] st;  
12.     private int top;  
13.     private int count;  
14.   
15.     /** 
16.      * 构造一个栈 
17.      *  
18.      * @param size 
19.      *            栈的大小 
20.      */  
21.     public Stack(int size) {  
22.         st = new int[size];  
23.         top = -1;  
24.         count = 0;  
25.     }  
26.   
27.     /** 
28.      * 元素进栈 
29.      *  
30.      * @param j 
31.      *            要进栈的元素 
32.      */  
33.   
34.     public void push(int j) {  
35.         count++;  
36.         st[++top] = j;  
37.     }  
38.   
39.     /** 
40.      * 元素出栈 
41.      *  
42.      * @return 出栈的元素 
43.      */  
44.   
45.     public int pop() {  
46.   
47.         return st[top--];  
48.     }  
49.   
50.     /** 
51.      * 查询栈顶元素 
52.      *  
53.      * @return 栈顶元素 
54.      */  
55.   
56.     public int peek() {  
57.         return st[top];  
58.     }  
59.   
60.     /** 
61.      * 查询栈是否为空 
62.      *  
63.      * @return 栈是否为空 
64.      */  
65.   
66.     public boolean isEmpty() {  
67.         count--;  
68.         return (top == -1);  
69.     }  
70.   
71.     /** 
72.      * 查看栈里的所有元素 
73.      */  
74.   
75.     public void list() {  
76.   
77.         for (int i = 0; i < count; i++) {  
78.   
79.             System.out.print(st[i] + "   ");  
80.   
81.         }  
82.         System.out.println();  
83.     }  
84.   
85.     /** 
86.      * 得到栈里一共有多少元素 
87.      *  
88.      * @return 栈里的元素个数 
89.      */  
90.     public int getCount() {  
91.         return count;  
92.     }  
93.   
94.     /** 
95.      * 查看栈里是否包含某个元素 
96.      *  
97.      * @param i 
98.      *            要查询的元素 
99.      * @return 是否包含了要查询的元素 
100.      */  
101.   
102.     public boolean isContains(int i) {  
103.         for (int k = 0; k < st.length; k++) {  
104.   
105.             System.out.print("开始比较" + i + "此时的result:");  
106.             list();  
107.             System.out.println();  
108.             if (st[k] == i) {  
109.                 return true;  
110.             }  
111.         }  
112.         return false;  
113.     }  
114.       
115.     /** 
116.      * 得到栈里的元素集 
117.      * @return 栈里的元素集合 
118.      */  
119.     public int[] getSt(){  
120.         return st;  
121.     }  
122.   
123. }  

 Graph类：

Java代码  

1. package com.javaeye.rsrt;  
2.   
3. import java.util.Arrays;  
4. import java.util.List;  
5. import java.util.Vector;  
6.   
7. /** 
8.  *  
9.  * @author nishiting 
10.  *  
11.  */  
12.   
13. public class Graph {  
14.   
15.     int vertexNum;  
16.     Vector[] vector;  
17.     Stack stack;  
18.     int[] result;  
19.     int[] in;// 入度  
20.   
21.     /** 
22.      *  
23.      * 构造一个图 
24.      *  
25.      * @param num 
26.      *            图的顶点数 
27.      *  
28.      */  
29.     public Graph(int num) {  
30.   
31.         vertexNum = num;  
32.         vector = new Vector[vertexNum];  
33.         stack = new Stack(num);  
34.         result = new int[vertexNum];  
35.         in = new int[vertexNum];  
36.   
37.     }  
38.   
39.     /** 
40.      * 向图中添加无向边 
41.      *  
42.      * @param I 
43.      *            边的一个顶点 
44.      * @param J 
45.      *            边的另一个顶点 
46.      * @return 是否添加成功 
47.      */  
48.     public boolean addEdge(int I, int J) {  
49.   
50.         /** 
51.          * 判断用户输入的是否是一个顶点，如果是，则返回flase,添加不成功 
52.          */  
53.         if (J == I) {  
54.             return false;  
55.         }  
56.   
57.         /** 
58.          * 判断所输入的顶点值是否在图所顶点范围值内，如果不在，则提示顶点不存在 
59.          *  
60.          */  
61.         if (I < vertexNum && J < vertexNum && I >= 0 && J >= 0) {  
62.   
63.             /** 
64.              *  
65.              * 判断边是否存在 
66.              */  
67.   
68.             if (isEdgeExists(I, J)) {  
69.   
70.                 return false;  
71.             }  
72.   
73.             /** 
74.              * 添加边，将孤头的入度加1 
75.              */  
76.   
77.             vector[I].add(J);  
78.             in[J]++;  
79.             return true;  
80.         }  
81.         return false;  
82.     }  
83.   
84.     /** 
85.      * 判断有向边是否存在 
86.      *  
87.      * @param i 
88.      *            要查询的有向边的一个孤尾 
89.      * @param j 
90.      *            要查询的有向边的另一个孤头 
91.      * @return 边是否存在，false:不存在，true:存在 
92.      */  
93.   
94.     public boolean isEdgeExists(int i, int j) {  
95.   
96.         /** 
97.          * 判断所输入的顶点值是否在图所顶点范围值内，如果不在，则提示顶点不存在 
98.          *  
99.          */  
100.         if (i < vertexNum && j < vertexNum && i >= 0 && j >= 0) {  
101.   
102.             if (i == j) {  
103.                 return false;  
104.             }  
105.   
106.             /** 
107.              * 判断i的邻接结点集是否为空 
108.              */  
109.   
110.             if (vector[i] == null) {  
111.                 vector[i] = new Vector(8);  
112.             }  
113.   
114.             /** 
115.              * 判断这条边是否存在，如果存在，则提示边已经存在 
116.              */  
117.             for (int q = 0; q < vector[i].size(); q++) {  
118.   
119.                 if (((Integer) vector[i].get(q)).intValue() == j) {  
120.                     System.out.println("顶点" + i + "和" + "顶点" + j + "这两点之间存在边");  
121.                     return true;  
122.   
123.                 }  
124.             }  
125.         }  
126.         return false;  
127.     }  
128.   
129.     public void TopSort() {  
130.   
131.         for (int i = 0; i < vertexNum; i++)  
132.             if (in[i] == 0)  
133.                 stack.push(i);  
134.         int k = 0;  
135.         while (!stack.isEmpty()) {  
136.   
137.             result[k] = (Integer) stack.pop();  
138.   
139.             if (vector[result[k]] != null) {  
140.                 for (int j = 0; j < vector[result[k]].size(); j++) {  
141.   
142.                     int temp = (Integer) vector[result[k]].get(j);  
143.                     if (--in[temp] == 0) {  
144.                         stack.push(temp);  
145.                     }  
146.   
147.                 }  
148.   
149.             }  
150.             k++;  
151.   
152.         }  
153.   
154.         if (k < vertexNum) {  
155.             System.out.println("有回路");  
156.             System.exit(0);  
157.   
158.         }  
159.   
160.     }  
161.   
162.     public int[] getResult() {  
163.         return result;  
164.   
165.     }  
166.   
167. }  

 测试类：

Java代码  

1. package com.javaeye.rsrt;  
2.   
3. import java.util.List;  
4.   
5. import junit.framework.TestCase;  
6.   
7. public class GraphTest extends TestCase {  
8.   
9.     public void testGraph(){  
10.         Graph graph = new Graph(6);  
11.         graph.addEdge(1, 0);  
12.         graph.addEdge(2, 0);  
13.         graph.addEdge(3, 0);  
14.         graph.addEdge(1, 3);  
15.         graph.addEdge(2, 3);  
16.         graph.addEdge(3, 5);  
17.         graph.addEdge(4, 2);  
18.         graph.addEdge(4, 3);  
19.         graph.addEdge(4, 5);  
20.           
21.         graph.TopSort();  
22.         int[] list = graph.getResult();  
23.         System.out.println("拓扑排序的结果为：");  
24.         for(int i : list){  
25.               
26.             System.out.print(i+"        ");  
27.         }  
28.     }  
29.       
30. }  

1 
顶

1 
踩

分享到：