Java實現無向圖的建立與遍歷

一、基於鄰接矩陣表示法的無向圖

　　鄰接矩陣是一種利用一維數組記錄點集信息、二維數組記錄邊集信息來表示圖的表示法，因此我們可以將圖抽象成一個類，點集信息和邊集信息抽象成類的屬性，就可以在Java中描述出來，代碼如下：

class AMGraph{
    
    private String[] vexs = null;  　　//點集信息
    
    private int[][] arcs = null;  　　 //邊集信息
    
}

　　每一個具體的圖，就是該類的一個實例化對象，因此我們可以在構造函數中實現圖的創建，代碼如下：

public AMGraph(int vexNum,int arcNum) {  　　　　　　　　//輸入點的個數和邊的個數
        
    this.vexs = new String[vexNum];
    this.arcs = new int[vexNum][vexNum];
        
    System.out.print("請依次輸入頂點值，以空格隔開：");
    Scanner sc = new Scanner(System.in);
    for(int i = 0; i < vexNum; i++) {  　　　　　　　　　//根據輸入建立點集
        this.vexs[i] = sc.next();
    }
        
    for(int i = 0; i < vexNum; i++) {  　　　　　　　　　//初始化邊集
        for(int j = 0; j < vexNum; j++) {
            this.arcs[i][j] = 0;  　　　　　　　　　　　　//0表示該位置所對應的兩頂點之間沒有邊
        }
    }
        
start:for(int i = 0; i < arcNum; i++) {  　　　　　//開始建立邊集
    
        sc = new Scanner(System.in);
        int vex1Site = 0;
        int vex2Site = 0;
        String vex1 = null;
        String vex2 = null;
            
        System.out.print("請輸入第" + (i+1) + "條邊所依附的兩個頂點，以空格隔開：");
        vex1 = sc.next();
        vex2 = sc.next();
        for(int j = 0; j < this.vexs.length; j++) {  　　//查找輸入的第一個頂點的位置
            if (this.vexs[j].equals(vex1)) {
                vex1Site = j;
                break;
            }
            if (j == this.vexs.length - 1) {
                System.out.println("未找到第一個頂點，請重新輸入！");
                i--;
                continue start;
            }
        }
        for (int j = 0; j < this.vexs.length; j++) {  　//查找輸入的第二個頂點的位置
            if(this.vexs[j].equals(vex2)) {
                vex2Site = j;
                break;
            }
            if (j == this.vexs.length - 1) {
                System.out.println("未找到第二個頂點，請重新輸入！");
                i--;
                continue start;
            }
        }
        if(this.arcs[vex1Site][vex2Site] != 0) {  　　　　//檢測該邊是否已經輸入
            System.out.println("該邊已存在！");
            i--;
            continue start;
        }else {
            this.arcs[vex1Site][vex2Site] = 1;  　　　　　//1表示該位置所對應的兩頂點之間有邊
            this.arcs[vex2Site][vex1Site] = 1;  　　　　　//對稱邊也置1
        }
    }
    System.out.println("基於鄰接矩陣的無向圖創建成功！");
    sc.close();
}

 　　創建好圖后，我們還要實現圖的遍歷。由於圖已經被我們抽象成一個類，因此我們可以將圖的遍歷定義成類的方法。對於連通圖，調用遍歷算法后即可訪問所有結點，但對於非連通圖，調用遍歷算法后仍有一些結點沒有被訪問，需要從圖中另選一個未被訪問的頂點再次調用遍歷算法。因此需要附設一個訪問標志數組visited[n]，來記錄被訪問的結點。增加了訪問標志數組的類屬性如下：

class AMGraph{
    
    private String[] vexs = null;
    
    private int[][] arcs = null;
    
    private boolean[] visited = null;  　　　//false表示該位置的頂點未訪問，true表示已訪問

}

　　圖的遍歷分為深度優先遍歷和廣度優先遍歷，接下來我們來分別實現它們。深度優先遍歷代碼如下：

public void dFSTraverse() {
        
    this.visited = new boolean[this.vexs.length];  　　 //初始化訪問標志數組
    for(int i = 0; i < this.visited.length; i++) {
        this.visited[i] = false;
    }
        
    for(int i = 0; i < this.visited.length; i++) {
        if(!this.visited[i]) {  　　　　　　　　　　　　　　//對未訪問的頂點調用深度優先遍歷算法
            dFS_AM(i);
        }
    }
}

public void dFS_AM(int site) {  　　　　　　　　　　　　　　//輸入深度優先遍歷的開始頂點
    System.out.println(this.vexs[site]);  　　　　　　　　//輸出該頂點
    this.visited[site] = true;  　　　　　　　　　　　　　　//置訪問標志為true
    for(int i = 0; i < this.vexs.length; i++) {  　　　 //依次查找未訪問鄰接點，並以該鄰接點為始點調用深度優先遍歷算法
        if(this.arcs[site][i] != 0 && !this.visited[i]) {
            this.dFS_AM(i);
        }
    }
}

　　廣度優先遍歷代碼如下：

public void bFSTraverse() {
        
    this.visited = new boolean[this.vexs.length];  　　　　//初始化訪問標志數組
    for(int i = 0; i < this.visited.length; i++) {
        this.visited[i] = false;
    }
        
    for(int i = 0; i < this.visited.length; i++) {
        if(!this.visited[i]) {  　　　　　　　　　　　　　　　//對未訪問的頂點調用廣度優先遍歷算法
            bFS_AM(i);
        }
    }
}

public void bFS_AM(int site) {  　　　　　　　　　　　　　　　　　　　　　　//輸入開始頂點
    System.out.println(this.vexs[site]);  　　　　　　　　　　　　　　　　//輸出該頂點
    this.visited[site] = true;  　　　　　　　　　　　　　　　　　　　　　　//置訪問標志為true
    LinkedList<Integer> linkedList = new LinkedList<Integer>();  　　//借助隊列來實現廣度優先遍歷
    linkedList.offer(site);  　　　　　　　　　　　　　　　　　　　　　　　 //將訪問過的頂點入隊
    while(!linkedList.isEmpty()) {
        int vexSite = linkedList.poll();  　　　　　　　　　　　　　　　 //隊頭頂點出隊
        for(int i = 0; i < this.vexs.length; i++) {
            if(this.arcs[vexSite][i] != 0 && !this.visited[i]) {  　//依次查找未訪問的鄰接點進行訪問后入隊
                System.out.println(this.vexs[i]);
                this.visited[i] = true;
                linkedList.offer(i);
            }
        }
    }
}

　　以上基於鄰接矩陣表示法的無向圖的類就定義好了，接着我們在客戶端里使用即可：

public class Main {

    public static void main(String[] args) {
                
        Scanner sc =  new Scanner(System.in);
        int vexNum = 0;
        int arcNum = 0;
        while(true) {
            System.out.print("請輸入要建立無向圖的總頂點數和總邊數，以空格隔開：");
            try {
                vexNum = sc.nextInt();
                arcNum = sc.nextInt();
                break;
            } catch (Exception e) {
                System.out.println("輸入不合法！");
                continue;
            }
        }
        
        AMGraph aMGraph = new AMGraph(vexNum, arcNum);
        System.out.println("由深度優先遍歷得：");
        aMGraph.dFSTraverse();
        System.out.println("由廣度優先遍歷得：");
        aMGraph.bFSTraverse();

        sc.close();
    }

}

二、基於鄰接表表示法的無向圖

　　鄰接表是一種基於鏈式存儲結構的表示法。在鄰接表中，對圖的每個頂點建立一個單鏈表，單鏈表的第一個結點存放頂點信息，稱為點結點，其余結點存放邊信息，稱為邊結點。此外，還需要一個頂點數組，存儲對所有單鏈表的引用。因此我們需要定義三個類，第一個類為頂點類，用來生成點結點；第二個類為邊類，用來生成邊結點；第三個類為圖類，里面定義有屬性——頂點數組和方法——圖的遍歷。代碼如下：

class ALGraph_Head{  　　　　　　　　　　　　　　　//頂點類
    
    private String data = null;  　　　　　　　　//點結點值
    
    private ALGraph_Arc firstArc= null;  　　　//第一條邊的指針
    
    public String getData() {
        return data;
    }
    
    public ALGraph_Arc getFirstArc() {
        return firstArc;
    }
    
    public void setFirstArc(ALGraph_Arc firstArc) {
        this.firstArc = firstArc;
    }
    
    public ALGraph_Head(String data) {
        this.data = data;
    }
}

class ALGraph_Arc{  　　　　　　　　　　　　　　　　//邊類
    
    private int adjVexSite = 0;  　　　　　　　　//該邊所連接的頂點的鄰接點的位置
    
    private ALGraph_Arc nextArc = null;  　　　//下一條邊的指針
    
    public int getAdjVexSite() {
        return adjVexSite;
    }
    
    public ALGraph_Arc getNextArc() {
        return nextArc;
    }
    
    public ALGraph_Arc(int adjVexSite, ALGraph_Arc nextArc) {
        this.adjVexSite = adjVexSite;
        this.nextArc = nextArc;
    }
}

class ALGraph{  　　　　　　　　　　　　　　　　　　　　　　//圖類
    
    private ALGraph_Head[] aLGraph_Heads = null;  　 //頂點數組

}

　　同樣的，我們在構造方法中進行圖的建立，代碼如下：

public ALGraph(int vexNum,int arcNum) {  　　　　　　　　　　//輸入頂點個數，邊的個數
        
    this.aLGraph_Heads = new ALGraph_Head[vexNum];
        
    System.out.print("請依次輸入頂點值，以空格隔開：");
    Scanner sc = new Scanner(System.in);
    for(int i = 0; i < vexNum; i++) {  　　　　　　　　　　　//建立頂點數組存儲點結點
        this.aLGraph_Heads[i] = new ALGraph_Head(sc.next());
    }
        
start:for(int i = 0; i < arcNum; i++) {  　　　　　　　//開始存儲邊信息
            
        sc = new Scanner(System.in);
        int vex1Site = 0;
        int vex2Site = 0;
        String vex1 = null;
        String vex2 = null;
            
        System.out.print("請輸入第" + (i+1) + "條邊所依附的兩個頂點，以空格隔開：");
        vex1 = sc.next();
        vex2 = sc.next();
        for(int j = 0; j < this.aLGraph_Heads.length; j++) {  　　　　　　//查找第一個頂點的位置
            if (this.aLGraph_Heads[j].getData().equals(vex1)) {
                vex1Site = j;
                break;
            }
            if (j == this.aLGraph_Heads.length - 1) {
                System.out.println("未找到第一個頂點，請重新輸入！");
                i--;
                continue start;
            }
        }
        for (int j = 0; j < this.aLGraph_Heads.length; j++) {  　　　　　 //查找第二個頂點的位置
            if(this.aLGraph_Heads[j].getData().equals(vex2)) {
                vex2Site = j;
                break;
            }
            if (j == this.aLGraph_Heads.length - 1) {
                System.out.println("未找到第二個頂點，請重新輸入！");
                i--;
                continue start;
            }
        }
        ALGraph_Arc aLGraph_Arc = this.aLGraph_Heads[vex1Site].getFirstArc();  　　　//獲取點結點里的邊指針
        while(aLGraph_Arc != null) {  　　　　　　　　　　　　　　　　　　　　　　　　　　　 //判斷邊是否已存儲
            if(aLGraph_Arc.getAdjVexSite() == vex2Site) {
                System.out.println("該邊已存在！");
                i--;
                continue start;
            }
            aLGraph_Arc = aLGraph_Arc.getNextArc();
        }
        this.aLGraph_Heads[vex1Site].setFirstArc(new ALGraph_Arc(vex2Site, this.aLGraph_Heads[vex1Site].getFirstArc()));  　　//將邊結點加入單鏈表中
        this.aLGraph_Heads[vex2Site].setFirstArc(new ALGraph_Arc(vex1Site, this.aLGraph_Heads[vex2Site].getFirstArc()));  　　//對稱邊結點也加入單鏈表
    }
    System.out.println("基於鄰接表的無向圖創建成功！");
    sc.close();
}

　　接着實現圖的遍歷，同樣需要附設一個訪問標志數組，因此將圖類屬性修改如下：

class ALGraph{
    
    private ALGraph_Head[] aLGraph_Heads = null;
    
    private boolean[] visited = null;  　　　　　　　　//訪問標志數組

}

　　深度優先遍歷：

public void dFSTraverse() {
        
    this.visited = new boolean[this.aLGraph_Heads.length];  　　//建立並初始化訪問標志數組
    for(int i = 0; i < this.visited.length; i++) {
        this.visited[i] = false;
    }
    
    for(int i = 0; i < this.visited.length; i++) {  　　　　　　 //以未訪問的點為始點調用深度優先遍歷算法
        if(!this.visited[i]) {
            dFS_AM(i);
        }
    }
}

public void dFS_AM(int site) {
    System.out.println(this.aLGraph_Heads[site].getData());  　　　　　　　 //輸出點值
    this.visited[site] = true;  　　　　　　　　　　　　　　　　　　　　　　　　　//置訪問標志為true
    ALGraph_Arc aLGraph_Arc = this.aLGraph_Heads[site].getFirstArc();  　 //獲取點結點中的邊指針
    while(aLGraph_Arc != null) {
        if(!visited[aLGraph_Arc.getAdjVexSite()]) {  　　　　　　　　　　　　//如果該邊所連接的頂點的鄰接點未訪問，則以該鄰接點為始點調用深度優先遍歷算法
            this.dFS_AM(aLGraph_Arc.getAdjVexSite());
        }
        aLGraph_Arc = aLGraph_Arc.getNextArc();  　　　　　　　　　　　　　　 //獲取下一條邊
    }
}

　　廣度優先遍歷：

public void bFSTraverse() {
        
this.visited = new boolean[this.aLGraph_Heads.length];  　　//建立並初始化訪問標志數組
for(int i = 0; i < this.visited.length; i++) {
    this.visited[i] = false;
    }
        
    for(int i = 0; i < this.visited.length; i++) {  　　　　 //以未訪問的點為始點調用廣度優先遍歷算法
        if(!this.visited[i]) {
            bFS_AM(i);
        }
    }
}

public void bFS_AM(int site) {
    System.out.println(this.aLGraph_Heads[site].getData());  　　　　　　//輸出點值
    this.visited[site] = true;  　　　　　　　　　　　　　　　　　　　　　　　 //置訪問標志為true
    LinkedList<Integer> linkedList = new LinkedList<Integer>();  　　　 //利用隊列實現廣度優先遍歷
    linkedList.offer(site);  　　　　　　　　　　　　　　　　　　　　　　　　　//點入隊
    while(!linkedList.isEmpty()) {
        int vexSite = linkedList.poll();  　　　　　　　　　　　　　　　　　//點出隊
        ALGraph_Arc aLGraph_Arc = this.aLGraph_Heads[vexSite].getFirstArc();  　　//獲取點結點中的邊指針
        while(aLGraph_Arc != null) {
            vexSite = aLGraph_Arc.getAdjVexSite();  　　　　　　　　　　　　　　　　　 //獲取該邊所連接的頂點的鄰接點
            if(!this.visited[vexSite]) {  　　　　　　　　　　　　　　　　　　　　　　　 //如果該鄰接點未訪問，則訪問
                System.out.println(this.aLGraph_Heads[vexSite].getData());
                this.visited[vexSite] = true;
                linkedList.offer(vexSite);  　　　　　　　　　　　　　　　　　　　　　　//被訪問的點入隊
            }
            aLGraph_Arc = aLGraph_Arc.getNextArc();  　　　　　　　　　　　　　　　　　//獲取下一個鄰接點
        }
    }
}

　　客戶端代碼如下：

public class Main {

    public static void main(String[] args) {
        
        Scanner sc =  new Scanner(System.in);
        int vexNum = 0;
        int arcNum = 0;
        while(true) {
            System.out.print("請輸入要建立無向圖的總頂點數和總邊數，以空格隔開：");
            try {
                vexNum = sc.nextInt();
                arcNum = sc.nextInt();
                break;
            } catch (Exception e) {
                System.out.println("輸入不合法！");
                continue;
            }
        }
        
        ALGraph aLGraph = new ALGraph(vexNum, arcNum);
        System.out.println("由深度優先遍歷得：");
        aLGraph.dFSTraverse();
        System.out.println("由廣度優先遍歷得：");
        aLGraph.bFSTraverse();

        sc.close();
    }

}

三、小結

　　以上雖然只實現了無向圖，但其實有向圖、無向網、有向網的建立和遍歷都同理，只需將代碼稍作修改，在邊信息中增加權值信息，用對稱邊記錄反方向的邊即可。