用邻接表表示图【java实现】

自己用java写了个图数据结构的简单实现，可以设置有向图和无向图。

 

该类还实现了迭代方法，广度优先和深度优先

 

源代码：

[java]  view plain

1. package my.graph;  
2. import java.util.ArrayList;  
3. import java.util.Iterator;  
4. import my.queue.*;  
5. import my.stack.StackX;  
6. /** 
7.  * 邻接表表示 
8.  * @author xiayi 
9.  * 
10.  */  
11. public class Graph {  
12.     private int MAX_VERTS = 20;  
13.     private Vertex vertexList[];  
14.     private boolean is = false;//是否为有向图  
15.     private int nVerts = 0;  
16.       
17.     private StackX stackX;  
18.     private Vertex dfs[];  
19.       
20.     private Vertex bfs[];  
21.     private Queue queue;  
22.       
23.       
24.     public Graph(){  
25.         vertexList = new Vertex[MAX_VERTS];  
26.         dfs = new Vertex[MAX_VERTS];  
27.         bfs = new Vertex[MAX_VERTS];  
28.     }  
29.     public Graph(int n){  
30.         vertexList = new Vertex[n];  
31.         dfs = new Vertex[n];  
32.         bfs = new Vertex[n];  
33.           
34.     }  
35.     public Graph(int n, boolean is){  
36.         this.is = is;  
37.         vertexList = new Vertex[n];  
38.         dfs = new Vertex[n];  
39.         bfs = new Vertex[n];  
40.     }  
41.     //  
42.     public boolean isIs() {  
43.         return is;  
44.     }  
45.     public void setIs(boolean is) {  
46.         this.is = is;  
47.     }  
48.     public Vertex[] getVertexList() {  
49.         return vertexList;  
50.     }  
51.     public Vertex[] getDfs() {  
52.         return dfs;  
53.     }  
54.     public Vertex[] getBfs() {  
55.         return bfs;  
56.     }  
57.       
58.       
59.     /** 
60.      * 添加顶点 
61.      */  
62.     public void addVertex(Vertex vertex){  
63.         vertex.setIndex(nVerts);  
64.         vertexList[nVerts] = vertex;  
65.         nVerts++;  
66.     }  
67.     /** 
68.      * 添加边 
69.      */  
70.     public void addEdge(int start, int end){  
71.         vertexList[start].addAdj(vertexList[end]);  
72.         if (!is) {vertexList[end].addAdj(vertexList[start]);}  
73.     }  
74.     /** 
75.      * 返回节点个数 
76.      * @return 
77.      */  
78.     public int getVertsCount(){  
79.         return vertexList.length;  
80.     }  
81.       
82.     /** 
83.      * 深度优先迭代器 
84.      * @return 
85.      */  
86.     public Iterator dfsIterator(){  
87.         dfs();  
88.         return new DfsIterator();  
89.     }  
90.     /** 
91.      * 广度优先迭代器 
92.      * @return 
93.      */  
94.     public Iterator bfsIterator(){  
95.         bfs();  
96.         return new BfsIterator();  
97.     }  
98.       
99.     public void displayGraph(){  
100.         ArrayList<Vertex> next = null;  
101.         for (int i = 0; i < vertexList.length; i++) {  
102.             printVertx(vertexList[i]);  
103.         }  
104.     }  
105.     public void printVertx(Vertex vertex){  
106.         ArrayList<Vertex> next = vertex.getAdj();  
107.         if(next == null){ System.out.println(vertex.toString()+" 无连接点");}  
108.         else{  
109.             System.out.print(vertex.toString()+"有邻接点:");  
110.             for (int i = 0; i < next.size(); i++) {  
111.                 System.out.print("顶点"+next.get(i).label+", ");  
112.             }  
113.             System.out.println();  
114.         }  
115.     }  
116.       
117.     ///  
118.       
119.     public void dfs(){  
120.         stackX = new StackX(MAX_VERTS);  
121.         vertexList[0].isVisted = true;  
122.         dfs[0] = vertexList[0];  
123.       
124.         stackX.push(vertexList[0]);  
125.         int dfsIndex = 0;  
126.           
127.         Vertex vertex;  
128.         while(!stackX.isEmpty()){  
129.             vertex = getAdjVertex((Vertex)stackX.peek());  
130.             if(vertex == null){  
131.                 stackX.pop();  
132.             }else{  
133.                 vertex.isVisted = true;  
134.                 dfs[++dfsIndex]=vertex;  
135.                 stackX.push(vertex);  
136.             }  
137.         }  
138.           
139.         for (int i = 0; i < getVertsCount(); i++) {  
140.             vertexList[i].isVisted = false;  
141.         }  
142.           
143.     }  
144.       
145.     public void bfs() {  
146.         queue = new Queue(MAX_VERTS);  
147.         vertexList[0].isVisted = true;  
148.         bfs[0] = vertexList[0];  
149.         queue.insert(vertexList[0]);  
150.         int bfsIndex = 0;  
151.         Vertex vertex;  
152.         while(!queue.isEmpty()){  
153.             Vertex vertex2 = (Vertex)queue.remove();  
154.             while((vertex = getAdjVertex(vertex2))!=null){  
155.                 vertex.isVisted = true;  
156.                 bfs[++bfsIndex] = vertex;  
157.                 queue.insert(vertex);  
158.             }  
159.         }  
160.           
161.         for (int i = 0; i < getVertsCount(); i++) {  
162.             vertexList[i].isVisted = false;  
163.         }  
164.     }  
165.     /** 
166.      * 得到一个邻接点 
167.      * @param vertex 
168.      * @return 
169.      */  
170.     public Vertex getAdjVertex(Vertex vertex){    
171.         ArrayList<Vertex> adjVertexs = vertex.getAdj();  
172.         for (int i = 0; i < adjVertexs.size(); i++) {  
173.             if(!adjVertexs.get(i).isVisted){  
174.                 return adjVertexs.get(i);  
175.             }  
176.         }  
177.         return null;  
178.     }  
179.     /  
180.     private abstract class GraphIterator implements Iterator{  
181.       
182.         int count = 0;  
183.         public GraphIterator(){  
184.         }  
185.         public boolean hasNext() {  
186.             return count != getVertsCount()-1;  
187.         }  
188.         public Object next() {        
189.             // TODO Auto-generated method stub  
190.             return null;  
191.         }  
192.         public void remove() {  
193.             // TODO Auto-generated method stub  
194.               
195.         }  
196.           
197.     }  
198.     //深度优先迭代  
199.     private class DfsIterator extends GraphIterator{  
200.         public DfsIterator(){  
201.             super();  
202.         }  
203.       
204.         public Vertex next() {        
205.             return dfs[count++];  
206.         }  
207.     }  
208.     //广度优先迭代  
209.     private class BfsIterator extends GraphIterator{  
210.         public BfsIterator(){  
211.             super();  
212.         }  
213.           
214.         public Object next() {        
215.             return bfs[count++];  
216.         }  
217.     }  
218.     /  
219.       
220.     public static void main(String[] args) {  
221.         int nVerts = 10;  
222.         int c = 'A'-1;  
223.         Vertex vertex;  
224.         Graph myGraph = new Graph(nVerts, false);  
225.         for (int i = 0; i < nVerts; i++) {  
226.             c++;  
227.             vertex = new Vertex((char)(c));  
228.             myGraph.addVertex(vertex);  
229.         }  
230.         myGraph.addEdge(0, 1);  
231.         myGraph.addEdge(0, 4);  
232.         myGraph.addEdge(1, 2);  
233.         myGraph.addEdge(2, 3);  
234.         myGraph.addEdge(4, 5);  
235.         myGraph.addEdge(4, 6);  
236.         myGraph.addEdge(5, 8);  
237.         myGraph.addEdge(6, 7);  
238.         myGraph.addEdge(7, 8);  
239.         myGraph.addEdge(8, 9);  
240.           
241.         System.out.println("深度优先迭代遍历：");  
242.         for (Iterator iterator = myGraph.dfsIterator(); iterator.hasNext();) {  
243.             vertex = (Vertex) iterator.next();  
244.             System.out.println(vertex.toString());  
245.               
246.         }  
247.           
248.         System.out.println("/n广度优先迭代遍历：");  
249.         for (Iterator iterator = myGraph.bfsIterator(); iterator.hasNext();) {  
250.             vertex = (Vertex) iterator.next();  
251.             System.out.println(vertex.toString());  
252.               
253.         }  
254.     }  
255. }  
256. class Vertex{  
257.     public char label;   
258.     public boolean isVisted;  
259.     public int index;  
260.     private ArrayList<Vertex> next = null;  
261.     public Vertex(char lab)  // constructor  
262.     {     
263.         label = lab;  
264.         isVisted = false;  
265.     }  
266.     //为节点添加邻接点  
267.     public void addAdj(Vertex ver){  
268.         if(next == null) next = new ArrayList<Vertex>();  
269.         next.add(ver);  
270.     }  
271.       
272.     public ArrayList<Vertex> getAdj(){  
273.         return next;  
274.     }  
275.       
276.     public void setIndex(int index){  
277.         this.index = index;  
278.     }  
279.       
280.     public String toString(){  
281.         return "顶点 "+label+",下标："+index+".";  
282.     }  
283. }