第5周作业——有向图邻接

1. import java.io.BufferedReader;    
2. import java.io.File;    
3. import java.io.FileReader;    
4. import java.util.ArrayList;    
5. import java.util.LinkedList;    
6. import java.util.List;    
7. import java.util.Queue;    
8. import java.util.Scanner;      
9. public class GraphReverse {    
10.    private int vertexNum;    
11.    private int arcNum;    
12.    private boolean visited[];    
13.    private List<ArrayList<Integer>> graphListS;    
14.    private List<ArrayList<Integer>> graphListF;    
15.    public GraphReverse(int vertexNum,int arcNum,List<ArrayList<Integer>> graphListS,List<ArrayList<Integer>> graphListF){    
16.        this.vertexNum=vertexNum;    
17.        this.graphListS=graphListS;    
18.        visited=new boolean[vertexNum];    
19.        this.graphListF=graphListF;    
20.    }      
21.    public static void main(String[] args) {    
22.     String path="f:/tinyDG.txt";    
23.     try{    
24.         Scanner scanner=new Scanner(new File(path));    
25.         List<ArrayList<Integer>> graphListS=new ArrayList<ArrayList<Integer>>();//存储有向图的邻接表    
26.         List<ArrayList<Integer>> graphListF=new ArrayList<ArrayList<Integer>>();//存储有向图的反向图的邻接表    
27.         int vertexNum=scanner.nextInt();    
28.         int arcNum=scanner.nextInt();    
29.          for(int i=0;i<vertexNum;i++){    
30.              graphListS.add(new ArrayList<Integer>());    
31.              graphListF.add(new ArrayList<Integer>());    
32.          }    
33.          //有向图的存储    
34.         for(int i=0;i<arcNum;i++){    
35.             int u=scanner.nextInt();    
36.             int v=scanner.nextInt();    
37.             if(!graphListS.get(u).contains(v)){    
38.                 graphListS.get(u).add(v);    
39.             }    
40.              //有向图的反向图存储    
41.             if(!graphListF.get(v).contains(u)){    
42.                 graphListF.get(v).add(u);    
43.             }                  
44.         }    
45.         //有向图的广度优先遍历    
46.         GraphReverse g1=new GraphReverse(vertexNum, arcNum, graphListS,null);    
47.         System.out.println("有向图的邻接表的结果是：");    
48.         g1.bfs(vertexNum/2+1,graphListS);   
49.         System.out.println(" ");  
50.         //有向图的反向图广度优先的遍历    
51.         GraphReverse g2=new GraphReverse(vertexNum, arcNum, null,graphListF);    
52.         System.out.println("有向图的反向图的邻接表结果是:");    
53.         g2.bfs(1,graphListF);              
54.     }catch (Exception e) {    
55.          e.printStackTrace();    
56.     }    
57.   }    
58.    private  void bfs(int v,List<ArrayList<Integer>> graphList){    
59.          Queue<Integer> que = new LinkedList<Integer>();       
60.          que.offer(v);    
61.         while (!que.isEmpty()) {       
62.           v = que.poll();      
63.           System.out.print(v+":");       
64.           visited[v] = true;       
65.           for (int i = 0; i <graphList.get(v).size(); i++) {      
66.            int k=graphList.get(v).get(i);     
67.            System.out.print(k+" ");    
68.            if (!visited[k]){     
69.               //que.add(k);     
70.               que.offer(k);    
71.               visited[k] = true;       
72.            }       
73.           }     
74.           System.out.println();    
75.        }       
76.    }    
77. }