拓扑排序-java实现

拓扑排序

拓扑概念：前后顶点是一对有序的顶点。

样例构造：

 

V1和V6无入度顶点，说明他们可以无条件进入。

想要进入V2，必须完成先决条件，进入V1.

同理，V3的先决条件是V1.

V5的先决条件是V3，V4，V6，三个顶点先完成。

 

[java]  view plain  copy

1. package 拓扑排序;  
2.   
3. import java.util.ArrayList;  
4.   
5. public class kaha {  
6.     static int dist[]=new int[7];  
7.     static int s[]=new int[7];  
8.     public static void main(String args[])  
9.     {  
10.         int N=6;  
11.         ArrayList rlist = new ArrayList();  
12.           
13.         int map[][]={  
14.                 {0,0,0,0,0,0,0},  
15.                 {0,0,1,1,1,0,0},  
16.                 {0,0,0,0,0,0,0},  
17.                 {0,0,1,0,0,1,0},  
18.                 {0,0,0,0,0,1,0},  
19.                 {0,0,0,0,0,0,0},  
20.                 {0,0,0,0,1,1,0}  
21.         };  
22.           
23.         for(int i=1;i<=N;i++){//初始化所有点的入度  
24.             for(int j=1;j<=N;j++)  
25.             {  
26.                 if(map[j][i]!=0){  
27.                     dist[i]++;  
28.                 }  
29.             }  
30.         }  
31.         //共有6个顶点需要检查  
32.         int tempsum=N;  
33.         while(tempsum>=1)  
34.         {  
35.             int i;  
36.             for(i=1;i<=N;i++)  
37.             {  
38.                 if(s[i]!=1&&dist[i]==0)//如果入度为而且没被决策过的点，说明这个点的先决条件都完成了，可以选上这个点了  
39.                 {  
40.                     s[i]=1;//标记为已决策  
41.                     rlist.add(i);//加入结果队列  
42.                     tempsum--;//每次减去1个顶点  
43.                     break;  
44.                 }  
45.             }  
46.               
47.             //更新被选出的点的邻接点  
48.             for(int j=1;j<=N;j++)  
49.             {  
50.                 //这里条件需要判断   
51.                 //这个点已经被加入不能走回头路，有无回路。  
52.                 //是i的邻接点  
53.                 if(s[j]!=1&&map[i][j]!=0)  
54.                         dist[j]--;//进行更新  
55.                 }  
56.               
57.               
58.         }  
59.           
60.         for(Object temp:rlist)System.out.print(" "+temp);  
61.           
62.     }   
63. }  

---------------------------------------------------------1/3更新----------------------------------------------

上述的代码存在一个缺陷：不能处理非拓扑图，也就是说如果一个图存在环路，则无法处理。

为什么存在拓扑图存在回路是不行的？

试着从实际意义上去理解：如果两个顶点A和B，互相联系的话，进入顶点A的先决条件是进入顶点B，而进入顶点B的条件是进入顶点A。这样就存在矛盾了，到底是应该先做哪一个呢。所以拓扑图是不允许有回路的。

 

 

反映到代码中如何检查存在环呢？

如果一个图存在环：按照kaha算法，进行到某一部分的时候，必定会有这种情况发生：

不存在入度为0的顶点，但是n个顶点却都还没全部执行完，这个时候就可以判定图存在环路了。

如果图中存在环，那么图必定存在上述的矛盾，所以可以使用这个方法来判断回路。

[java]  view plain  copy

1. package 拓扑排序;  
2.   
3. import java.util.ArrayList;  
4.   
5. public class kaha {  
6.     static int dist[]=new int[7];  
7.     static int s[]=new int[7];  
8.     public static void main(String args[])  
9.     {  
10.         int N=6;  
11.         ArrayList rlist = new ArrayList();  
12.         //无环拓扑图  
13.         /*int map[][]={ 
14.                 {0,0,0,0,0,0,0}, 
15.                 {0,0,1,1,1,0,0}, 
16.                 {0,0,0,0,0,0,0}, 
17.                 {0,0,1,0,0,1,0}, 
18.                 {0,0,0,0,0,1,0}, 
19.                 {0,0,0,0,0,0,0}, 
20.                 {0,0,0,0,1,1,0} 
21.         };*/  
22.           
23.         //有环拓扑图  
24.         int map[][]={  
25.                 {0,0,0,0,0,0,0},  
26.                 {0,0,1,1,1,0,0},  
27.                 {0,1,0,0,0,0,0},//2-->1 由0改成1,2-->1存在一条回路。  
28.                 {0,0,1,0,0,1,0},  
29.                 {0,0,0,0,0,1,0},  
30.                 {0,0,0,0,0,0,0},  
31.                 {0,0,0,0,1,1,0}  
32.         };  
33.           
34.         for(int i=1;i<=N;i++){//初始化所有点的入度  
35.             for(int j=1;j<=N;j++)  
36.             {  
37.                 if(map[j][i]!=0){  
38.                     dist[i]++;  
39.                 }  
40.             }  
41.         }  
42.         //共有6个顶点需要检查  
43.         int tempsum=N;  
44.         while(tempsum>=1)  
45.         {  
46.             int i;  
47.             for(i=1;i<=N;i++)  
48.             {  
49.                 if(s[i]!=1&&dist[i]==0)//如果入度为而且没被决策过的点，说明这个点的先决条件都完成了，可以选上这个点了  
50.                 {  
51.                     s[i]=1;//标记为已决策  
52.                     rlist.add(i);//加入结果队列  
53.                     tempsum--;//每次减去1个顶点  
54.                     break;  
55.                 }  
56.             }  
57.               
58.             //判断是否能够找到入度为0的新顶点  
59.             if(i<=N)  
60.             {  
61.                 //更新被选出的点的邻接点  
62.                 for(int j=1;j<=N;j++)  
63.                 {  
64.                     //这里条件需要判断   
65.                     //这个点已经被加入不能走回头路，有无回路。  
66.                     //是i的邻接点  
67.                     if(s[j]!=1&&map[i][j]!=0){  
68.                             dist[j]--;//进行更新  
69.                     }  
70.                 }  
71.             }  
72.             else  
73.             {  
74.                 System.out.println("此图存在环路，非拓扑图");  
75.                 break;  
76.             }  
77.               
78.         }     
79.           
80.         if(tempsum==0)  
81.             for(Object temp:rlist)System.out.print(" "+temp);  
82.           
83.     }   
84. }