Java實現圖的遍歷（深搜與廣搜）

本文以鄰接矩陣作爲存儲結構，用Java實現圖的遍歷，話不多說，先給出的圖的結構，如下： 

1、深度優先搜索遍歷 
思想： 
沿着樹的深度遍歷樹的節點，儘可能深的搜索樹的分支。當節點v的所有邊都己被探尋過，搜索將回溯到發現節點v的那條邊的起始節點。這一過程一直進行到已發現從源節點可達的所有節點爲止。如果還存在未被發現的節點，則選擇其中一個作爲源節點並重復以上過程，整個進程反覆進行直到所有節點都被訪問爲止。（百度百科）

代碼如下：

package com.ds.graph;

public class DFSTraverse {
    // 構造圖的邊
    private int[][] edges = { { 0, 1, 0, 0, 0, 1, 0, 0, 0 },
            { 1, 0, 1, 0, 0, 0, 1, 0, 1 }, { 0, 1, 0, 1, 0, 0, 0, 0, 1 },
            { 0, 0, 1, 0, 1, 0, 1, 1, 1 }, { 0, 0, 0, 1, 0, 1, 0, 1, 0 },
            { 1, 0, 0, 0, 1, 0, 1, 0, 0 }, { 0, 1, 0, 1, 0, 1, 0, 1, 0 },
            { 0, 0, 0, 1, 1, 0, 1, 0, 0 }, { 0, 1, 1, 1, 0, 0, 0, 0, 0 } };
    // 構造圖的頂點
    private String[] vertexs = { "A", "B", "C", "D", "E", "F", "G", "H", "I" };
    // 記錄被訪問頂點
    private boolean[] verStatus;
    // 頂點個數
    private int vertexsNum = vertexs.length;

    public void DFSTra() {
        verStatus = new boolean[vertexsNum];
        for (int i = 0; i < vertexsNum; i++) {
            if (verStatus[i] == false) {
                DFS(i);
            }
        }
    }

    // 遞歸深搜
    private void DFS(int i) {
        System.out.print(vertexs[i] + " ");
        verStatus[i] = true;
        for (int j = firstAdjVex(i); j >= 0; j = nextAdjvex(i, j)) {
            if (!verStatus[j]) {
                DFS(j);
            }
        }
    }

    // 返回與i相連的第一個頂點
    private int firstAdjVex(int i) {
        for (int j = 0; j < vertexsNum; j++) {
            if (edges[i][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    // 返回與i相連的下一個頂點
    private int nextAdjvex(int i, int k) {
        for (int j = (k + 1); j < vertexsNum; j++) {
            if (edges[i][j] == 1) {
                return j;
            }
        }
        return -1;
    }

    // 測試
    public static void main(String[] args) {
        new DFSTraverse().DFSTra();
    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63

2、廣度優先搜索遍歷 
思想： 
從根節點開始，沿着樹的寬度、按照層次依次遍歷樹的節點；

代碼如下：

package com.ds.graph;

import java.util.LinkedList;
import java.util.Queue;

public class BFSTraverse_0100 {
    // 構造圖的邊
    private int[][] edges = { { 0, 1, 0, 0, 0, 1, 0, 0, 0 },
            { 1, 0, 1, 0, 0, 0, 1, 0, 1 }, { 0, 1, 0, 1, 0, 0, 0, 0, 1 },
            { 0, 0, 1, 0, 1, 0, 1, 1, 1 }, { 0, 0, 0, 1, 0, 1, 0, 1, 0 },
            { 1, 0, 0, 0, 1, 0, 1, 0, 0 }, { 0, 1, 0, 1, 0, 1, 0, 1, 0 },
            { 0, 0, 0, 1, 1, 0, 1, 0, 0 }, { 0, 1, 1, 1, 0, 0, 0, 0, 0 } };
    // 構造圖的頂點
    private String[] vertexs = { "A", "B", "C", "D", "E", "F", "G", "H", "I" };
    // 記錄被訪問頂點
    private boolean[] verStatus;
    // 頂點個數
    private int vertexsNum = vertexs.length;

    // 廣搜
    private void BFS() {
        verStatus = new boolean[vertexsNum];
        Queue<Integer> temp = new LinkedList<Integer>();
        for (int i = 0; i < vertexsNum; i++) {
            if (!verStatus[i]) {
                System.out.print(vertexs[i] + " ");
                verStatus[i] = true;
                temp.offer(i);
                while (!temp.isEmpty()) {
                    int j = temp.poll();
                    for (int k = firstAdjvex(j); k >= 0; k = nextAdjvex(j, k)) {
                        if (!verStatus[k]) {
                            System.out.print(vertexs[k] + " ");
                            verStatus[k] = true;
                            temp.offer(k);
                        }
                    }
                }
            }
        }
    }

    // 返回與i相連的第一個頂點
    private int firstAdjvex(int i) {
        for (int j = 0; j < vertexsNum; j++) {
            if (edges[i][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    // 返回與i相連的下一個頂點
    private int nextAdjvex(int i, int k) {
        for (int j = (k + 1); j < vertexsNum; j++) {
            if (edges[i][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    // 測試
    public static void main(String args[]) {
        new BFSTraverse_0100().BFS();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68

二：

import java.util.*;

/**
  *  這個例子是圖的遍歷的兩種方式
  *  通過它，使我來理解圖的遍歷
  *  Created on 2013-11-18
  *  @version 0.1
  */
public class DeptSearch
{
    public static void main(String args[]){
        //構造需要點對象
        NodeT a=new NodeT("a");
        NodeT b=new NodeT("b");
        NodeT c=new NodeT("c");
        NodeT d=new NodeT("d");
        NodeT e=new NodeT("e");
        NodeT f=new NodeT("f");
        NodeT g=new NodeT("g");
        NodeT h=new NodeT("h");
        ArcT ab=new ArcT(a,b);
        ArcT ac=new ArcT(a,c);
        ArcT ad=new ArcT(a,d);
        ArcT ah=new ArcT(a,h);
        ArcT bc=new ArcT(b,c);
        ArcT de=new ArcT(d,e);
        ArcT ef=new ArcT(e,f);
        ArcT eg=new ArcT(e,g);
        ArcT hg=new ArcT(h,g);

        //建立它們的關係
        a.outgoing.add(ab);
        a.outgoing.add(ac);
        a.outgoing.add(ad);
        a.outgoing.add(ah);
        b.outgoing.add(bc);
        d.outgoing.add(de);
        e.outgoing.add(ef);
        e.outgoing.add(eg);
        h.outgoing.add(hg);

        //構造本對象
        DeptSearch search=new DeptSearch();

        //廣度遍歷
        System.out.println("廣度遍歷如下：");
        search.widthSearch(a);

        //深度遍歷
        System.out.println("深度遍歷如下：");
        List<NodeT> visited=new ArrayList<NodeT>();
        search.deptFisrtSearch(a,visited);

    }

    /*
     * 深度排序的方法
     * 這個方法的方式：按一個節點，一直深入的找下去，直到它沒有節點爲止
     * cur  當前的元素
     * visited 訪問過的元素的集合
     */
    void deptFisrtSearch(NodeT cur,List<NodeT> visited){
        //被訪問過了，就不訪問，防止死循環
        if(visited.contains(cur)) return;
        visited.add(cur);
        System.out.println("這個遍歷的是："+cur.word);
        for(int i=0;i<cur.outgoing.size();i++){
            //訪問本點的結束點
            deptFisrtSearch(cur.outgoing.get(i).end,visited);
        }
    }

    /**
     * 廣度排序的方法
     * 這個方法的方式：按層次對圖進行訪問，先第一層，再第二層，依次類推
     * @param start 從哪個開始廣度排序
     */
    void widthSearch(NodeT start){
        //記錄所有訪問過的元素
        Set<NodeT> visited=new HashSet<NodeT>();
        //用隊列存放所有依次要訪問元素
        Queue<NodeT> q=new LinkedList<NodeT>();
        //把當前的元素加入到隊列尾
        q.offer(start);

        while(!q.isEmpty()){
            NodeT cur=q.poll();
            //被訪問過了，就不訪問，防止死循環
            if(!visited.contains(cur)){
                visited.add(cur);
                System.out.println("查找的節點是："+cur.word);
                for(int i=0;i<cur.outgoing.size();i++){
                    //把它的下一層，加入到隊列中
                    q.offer(cur.outgoing.get(i).end);
                }
            }
        }
    }

}

/**
  * 圖的點
  */
class NodeT
{
    /* 點的所有關係的集合 */
    List<ArcT> outgoing;
    //點的字母
    String word;
    public NodeT(String word){
        this.word=word;
        outgoing=new ArrayList<ArcT>();
    }
}

/**
  * 單個圖點的關係
  */
class ArcT
{
    NodeT start,end;/* 開始點，結束點 */
    public ArcT(NodeT start,NodeT end){
        this.start=start;
        this.end=end;
    }
}