java图的遍历方式(深度遍历、广度遍历)

[java]  view plain copy

1. import java.util.*;  
2.   
3. /** 
4.   *  这个例子是图的遍历的两种方式 
5.   *  通过它，使我来理解图的遍历  
6.   *  Created on 2013-11-18 
7.   *  @version 0.1 
8.   */  
9. public class DeptSearch  
10. {  
11.     public static void main(String args[]){  
12.         //构造需要点对象  
13.         NodeT a=new NodeT("a");  
14.         NodeT b=new NodeT("b");  
15.         NodeT c=new NodeT("c");  
16.         NodeT d=new NodeT("d");  
17.         NodeT e=new NodeT("e");  
18.         NodeT f=new NodeT("f");  
19.         NodeT g=new NodeT("g");  
20.         NodeT h=new NodeT("h");  
21.         ArcT ab=new ArcT(a,b);  
22.         ArcT ac=new ArcT(a,c);  
23.         ArcT ad=new ArcT(a,d);  
24.         ArcT ah=new ArcT(a,h);  
25.         ArcT bc=new ArcT(b,c);  
26.         ArcT de=new ArcT(d,e);  
27.         ArcT ef=new ArcT(e,f);  
28.         ArcT eg=new ArcT(e,g);  
29.         ArcT hg=new ArcT(h,g);  
30.   
31.         //建立它们的关系  
32.         a.outgoing.add(ab);  
33.         a.outgoing.add(ac);  
34.         a.outgoing.add(ad);  
35.         a.outgoing.add(ah);  
36.         b.outgoing.add(bc);  
37.         d.outgoing.add(de);  
38.         e.outgoing.add(ef);  
39.         e.outgoing.add(eg);  
40.         h.outgoing.add(hg);  
41.   
42.         //构造本对象  
43.         DeptSearch search=new DeptSearch();  
44.           
45.         //广度遍历  
46.         System.out.println("广度遍历如下：");  
47.         search.widthSearch(a);  
48.   
49.         //深度遍历  
50.         System.out.println("深度遍历如下：");  
51.         List<NodeT> visited=new ArrayList<NodeT>();  
52.         search.deptFisrtSearch(a,visited);  
53.           
54.     }  
55.       
56.     /* 
57.      * 深度排序的方法 
58.      * 这个方法的方式：按一个节点，一直深入的找下去，直到它没有节点为止 
59.      * cur  当前的元素 
60.      * visited 访问过的元素的集合 
61.      */  
62.     void deptFisrtSearch(NodeT cur,List<NodeT> visited){  
63.         //被访问过了，就不访问，防止死循环  
64.         if(visited.contains(cur)) return;  
65.         visited.add(cur);  
66.         System.out.println("这个遍历的是："+cur.word);  
67.         for(int i=0;i<cur.outgoing.size();i++){  
68.             //访问本点的结束点  
69.             deptFisrtSearch(cur.outgoing.get(i).end,visited);  
70.         }  
71.     }  
72.   
73.     /** 
74.      * 广度排序的方法 
75.      * 这个方法的方式：按层次对图进行访问，先第一层，再第二层，依次类推 
76.      * @param start 从哪个开始广度排序 
77.      */  
78.     void widthSearch(NodeT start){  
79.         //记录所有访问过的元素  
80.         Set<NodeT> visited=new HashSet<NodeT>();  
81.         //用队列存放所有依次要访问元素  
82.         Queue<NodeT> q=new LinkedList<NodeT>();  
83.         //把当前的元素加入到队列尾  
84.         q.offer(start);  
85.           
86.         while(!q.isEmpty()){  
87.             NodeT cur=q.poll();  
88.             //被访问过了，就不访问，防止死循环  
89.             if(!visited.contains(cur)){  
90.                 visited.add(cur);  
91.                 System.out.println("查找的节点是："+cur.word);  
92.                 for(int i=0;i<cur.outgoing.size();i++){  
93.                     //把它的下一层，加入到队列中  
94.                     q.offer(cur.outgoing.get(i).end);  
95.                 }  
96.             }  
97.         }  
98.     }  
99.   
100. }  
101.   
102. /** 
103.   * 图的点 
104.   */  
105. class NodeT  
106. {  
107.     /* 点的所有关系的集合 */  
108.     List<ArcT> outgoing;  
109.     //点的字母  
110.     String word;  
111.     public NodeT(String word){  
112.         this.word=word;  
113.         outgoing=new ArrayList<ArcT>();  
114.     }  
115. }  
116.   
117. /** 
118.   * 单个图点的关系 
119.   */  
120. class ArcT  
121. {  
122.     NodeT start,end;/* 开始点，结束点 */  
123.     public ArcT(NodeT start,NodeT end){  
124.         this.start=start;  
125.         this.end=end;  
126.     }  
127. }