2. 程式人生 > >使用鄰接矩陣實現圖結構

使用鄰接矩陣實現圖結構

阿新 • • 發佈：2019-02-03

　　關於圖的一些特點就不說了，現在我們先展示的是頂點的實現

/**
 * Created by 西皮 on 2017/9/15 19:58.
 * 圖的頂點類
 */
public class MyVertex<VItem> {
    private VItem data;//資料
    private int inDegree,outDegree;//出入度數
    private VStatus status;//狀態
    private long dTime,fTime;//時間標籤
    private int parent;//在遍歷樹中的父節點
    private int priority;//在遍歷樹中的優先順序
 


    public MyVertex(VItem data){
        this.data = data;
        this.inDegree = 0;
        this.outDegree = 0;
        this.status = VStatus.UNDISCOVERED;
        this.dTime = -1;
        this.fTime = -1;
        this.parent = -1;
        this.priority = Integer.MAX_VALUE;
    }

    public VItem getData
 
() {
        return data;
    }

    public void setData(VItem data) {
        this.data = data;
    }

    public int getInDegree() {
        return inDegree;
    }

    public void setInDegree(int inDegree) {
        this.inDegree = inDegree;
    }

    public int getOutDegree() {
        return outDegree;
    }

    public
 
 void setOutDegree(int outDegree) {
        this.outDegree = outDegree;
    }

    public VStatus getStatus() {
        return status;
    }

    public void setStatus(VStatus status) {
        this.status = status;
    }

    public long getdTime() {
        return dTime;
    }

    public void setdTime(long dTime) {
        this.dTime = dTime;
    }

    public long getfTime() {
        return fTime;
    }

    public void setfTime(long fTime) {
        this.fTime = fTime;
    }

    public int getParent() {
        return parent;
    }

    public void setParent(int parent) {
        this.parent = parent;
    }

    public int getPriority() {
        return priority;
    }

    public void setPriority(int priority) {
        this.priority = priority;
    }
}

　　這裡的屬性，status使用的enum來標識的，三種頂點狀態，分別是UNDISCOVERED，DISCOVERED，VISITED，分別用來表示未被發現，已被發現但是還未訪問完畢，已經被訪問完畢

/**
 * Created by 西皮 on 2017/9/16 9:49.
 * 定義頂點狀態的列舉類
 */
public enum VStatus {
    UNDISCOVERED("UNDISCOVERED"),DISCOVERED("DISCOVERED"),VISITED("VISITED");

    private final String value;

    VStatus(String value){
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

　　接下來展示邊

/**
 * Created by 西皮 on 2017/9/16 10:09.
 * 圖的邊類
 */
public class MyEdge<EItem> {
    private EItem data;//資料
    private int weight;//權重
    private EType type;//在便利書中所屬的型別

    public MyEdge(EItem data,int weight){
        this.data = data;
        this.weight = weight;
        this.type = EType.UNDETERMINED;
    }

    public EItem getData() {
        return data;
    }

    public void setData(EItem data) {
        this.data = data;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public EType getType() {
        return type;
    }

    public void setType(EType type) {
        this.type = type;
    }
}

　　這裡的邊同樣使用enum來表示邊的狀態

/**
 * Created by 西皮 on 2017/9/16 9:55.
 * 定義邊狀態的列舉類
 */
public enum EType {
    UNDETERMINED("UNDETERMINED"),TREE("TREE"),
    CROSS("CROSS"),FORWARD("FORWARD"),BACKWARD("BACKWARD");

    private final String value;

    EType(String value){
        this.value = value;
    }

    public String getValue(){
        return value;
    }
}

　　UNDETERMINED圖初始化時，所有邊預設是UNDETERMINED，其他的邊狀態需要結合圖的BFS和DFS來看，更簡單，這裡我們暫且放一邊。

　　接下來，我們來實現一個圖

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * Created by 西皮 on 2017/9/16 10:13.
 * 矩陣圖
 */
public class MyGrapMatrix<VItem,EItem> {

    private List<MyVertex<VItem>> V = new ArrayList<>();//頂點集

    private List<List<MyEdge<EItem>>> E = new ArrayList<>();//邊集，使用一個鄰接矩陣來表示邊

    private int n;//頂點數量

    private int e;//邊的數量

    public MyGrapMatrix(){}

    public VItem getMyVertex(int i){
        return V.get(i).getData();//獲得資料
    }

    public int getMyVertexInDegree(int i){
        return V.get(i).getInDegree();//獲得頂點入度
    }

    public int getMyVertexOutDegree(int i){
        return V.get(i).getOutDegree();
    }

    public VStatus getMyVertexStatus(int i){
        return V.get(i).getStatus();
    }

    public int getVertexNum(){
        return n;
    }

    public int getEdgeNum(){
        return e;
    }

    public long getMyVertexDTime(int i){
        return V.get(i).getdTime();
    }

    public long getMyVertexFTime(int i){
        return V.get(i).getfTime();
    }

    public int getMyVertexParent(int i){
        return V.get(i).getParent();
    }

    public int getMyVertexPriority(int i){
        return V.get(i).getPriority();
    }

    /**
     * 獲得當前節點i的比j小的下一個鄰居
     * @param i
     * @param j
     * @return
     */
    public int nextNbr(int i,int j){
        while (-1 < j && !exisits(i,--j));
        return j;
    }

    /**
     * 獲得頂點i的首個鄰居
     * @param i
     * @return
     */
    public int firstNbr(int i){
        return nextNbr(i,V.size());
    }

    /**
     * 判斷兩個頂點是否有邊
     * @param i
     * @param j
     * @return
     */
    public boolean exisits(int i,int j){
        if((0 <= i) && (i < n) &&
                (0 <= j) && (j < n) &&
                (E.get(i).get(j) != null))
            return true;
        return false;
    }

    /**
     * 獲得邊(i,j)的資料
     * @param i
     * @param j
     * @return
     */
    public EItem getMyEdgeData(int i,int j){
        return E.get(i).get(j).getData();
    }

    public EType getMyEdgeStatus(int i,int j){
        return E.get(i).get(j).getType();
    }

    public int getMyEdgeWeight(int i,int j){
        return E.get(i).get(j).getWeight();
    }

    /**
     * 插入一條邊，邊的兩個頂點分別是i和j
     * @param edgeData
     * @param weight
     * @param i
     * @param j
     */
    public void insertEdge(EItem edgeData,int weight,int i,int j){
        if (exisits(i,j)) return;//忽略已有的邊
        E.get(i).set(j,new MyEdge<EItem>(edgeData,weight));
        e++;//更新邊計數
        //更新關聯頂點i的出度和j的入度
        V.get(i).setOutDegree(V.get(i).getOutDegree()+1);
        V.get(j).setInDegree(V.get(j).getInDegree()+1);
    }

    /**
     * 刪除邊（i，j）
     * @param i
     * @param j
     * @return
     */
    public EItem removeEdge(int i,int j){
        EItem eBak = getMyEdgeData(i,j);
        E.get(i).set(j,null);//刪除邊（i，j）
        e--;//更新邊計數
        V.get(i).setOutDegree(V.get(i).getOutDegree()-1);
        V.get(j).setInDegree(V.get(j).getInDegree()-1);
        return eBak;
    }

    /**
     * 頂點插入
     * @param vertexData
     * @return
     */
    public int insertVertex(VItem vertexData){
        for (int j = 0;j < n;j++) E.get(j).add(null);
        n++;
        ArrayList<MyEdge<EItem>> lineEdges = new ArrayList<>(n);
        for (int i = 0;i < n;i++){
            lineEdges.add(null);
        }
        E.add(lineEdges);
        V.add(new MyVertex<VItem>(vertexData));
        return n-1;
    }

    /**
     * 刪除頂點及其關聯邊，返回該頂點資訊
     * @param i
     * @return
     * 索引所對應的頂點就改變了
     */
    public VItem removeVertex(int i){
        for (int j = 0;j < n;j++){
            if(exisits(i,j)){
                removeEdge(i,j);
            }
        }
        E.remove(i);n--;//刪除第i行
        VItem vBak = V.get(i).getData();V.remove(i);//備份之後，刪除頂點i
        for (int j = 0;j < n;j++){//刪除所有入邊及第i列
            E.get(j).remove(i);
            V.get(j).setOutDegree(V.get(j).getOutDegree()-1);
        }
        return vBak;//返回被刪除頂點的資訊
    }

    private int BFSclock = 0;
    /**
     * 廣度優先搜尋Breadth-First Search
     * @param v
     */
    public void BFS(int v){
        MyQueue<Integer> Q = new MyQueue<>();
        V.get(v).setStatus(VStatus.DISCOVERED);
        Q.enqueue(v);
        while (!Q.isEmpty()){
            v = Q.dequeue();
            System.out.println(V.get(v).getData());
            V.get(v).setdTime(++BFSclock);//取出對首頂點v，並給個時間戳
            //考察v的每一個鄰居u
            for (int u = firstNbr(v);-1 < u; u = nextNbr(v,u)){
                if (VStatus.UNDISCOVERED == V.get(u).getStatus()){
                    //若u尚未被發現
                    V.get(u).setStatus(VStatus.DISCOVERED);
                    Q.enqueue(u);//發現該頂點
                    //將他們之間的邊設定為TREE邊
                    E.get(v).get(u).setType(EType.TREE);
                    //把u在遍歷樹中的父節點設定成v
                    V.get(u).setParent(v);
                }else {
                    E.get(v).get(u).setType(EType.CROSS);
                }
            }
            //至此，當前頂點訪問完畢
            V.get(v).setStatus(VStatus.VISITED);
        }
    }

    /**
     * @param s
     */
    public void bfs(int s){//s為初始頂點
        BFSclock = 0;
        int v = s;
        do {
            if(VStatus.UNDISCOVERED == V.get(v).getStatus())
            BFS(v);//即從該頂點出發啟動一次BFS
        }while (s != (v = (++v % n)));
    }




    private int DFSclock = 0;

    /**
     * 深度優先遍歷
     * @param v
     */
    public void DFS(int v){
        V.get(v).setdTime(++DFSclock);
        V.get(v).setStatus(VStatus.DISCOVERED);//發現當前頂點v
        System.out.println(V.get(v).getData());
        for (int u = firstNbr(v); -1 < u; u = nextNbr(v,u)){//列舉v的每一鄰居u
            switch (V.get(u).getStatus()){//並視其狀態分別處理
                case UNDISCOVERED://u尚未發現，意味著支撐樹可在此擴充套件
                    E.get(v).get(u).setType(EType.TREE);
                    V.get(u).setParent(v);
                    DFS(u);
                    break;
                case DISCOVERED://u已被發現但尚未訪問完畢，應屬被後代指向的祖先
                    E.get(v).get(u).setType(EType.BACKWARD);
                    break;
                default://u已訪問完畢（VISITED，有向圖），則視承襲關係分為前向邊或跨邊
                    E.get(v).get(u).setType(V.get(v).getdTime()<V.get(u).getdTime()?EType.FORWARD:EType.CROSS);
                    break;
            }//switch
        }
        V.get(v).setStatus(VStatus.VISITED);
        V.get(v).setfTime(++DFSclock);//至此，當前頂點v方告訪問完畢
    }

    public void dfs(int s){//s為初始頂點
        DFSclock = 0;
        int v = s;
        do {
            if(VStatus.UNDISCOVERED == V.get(v).getStatus())
                DFS(v);//即從該頂點出發啟動一次BFS
        }while (s != (v = (++v % n)));
    }

}

　　頂點集使用一個ArrayList，這是一個數組，使用它的索引來標識不同的頂點，而邊則使用的是一個二維陣列來來表示，這樣會使他的空間複雜度為Θ(n^2)。
　　
　　這個導致這種結構所使用儲存空間和這個圖的邊數沒有關係，所以像這樣使用鄰接矩陣實現的圖更適合稠密圖。

　　在這裡我們首先看看這裡的exists()方法

 /**
     * 判斷兩個頂點是否有邊
     * @param i
     * @param j
     * @return
     */
    public boolean exisits(int i,int j){
        if((0 <= i) && (i < n) &&
                (0 <= j) && (j < n) &&
                (E.get(i).get(j) != null))
            return true;
        return false;
    }

　　我們首先需要確定ｉ和ｊ這兩個表示頂點的序號是可用的，然後在去表示邊的矩陣中查詢從ｉ指向ｊ的這條邊是否存在，也就是我們是否把MyEdge的物件存放進這個矩陣中，為null則不存在，否則存在。

　　接下來，我們來看看firstNbr（int i）和nextNbr(int i)這兩個方法

/**
     * 獲得當前節點i的比j小的下一個鄰居
     * @param i
     * @param j
     * @return
     */
    public int nextNbr(int i,int j){
        while (-1 < j && !exisits(i,--j));
        return j;
    }

    /**
     * 獲得頂點i的首個鄰居
     * @param i
     * @return
     */
    public int firstNbr(int i){
        return nextNbr(i,V.size());
    }

　　呼叫firstNbr()可以獲得i頂點的從尾部開始的第一個鄰居，而nextNbr()可以循著這個方向向前再找一個新鄰居，這裡在遍歷中時非常有用的。

　　接下來是對圖的動態操作，分別為對邊的新增刪除，和對頂點的新增刪除，邊的新增刪除沒什麼問題，看看程式碼就夠了，這裡我們著重看一看頂點的新增刪除

 /**
     * 頂點插入
     * @param vertexData
     * @return
     */
    public int insertVertex(VItem vertexData){
        for (int j = 0;j < n;j++) E.get(j).add(null);
        n++;
        ArrayList<MyEdge<EItem>> lineEdges = new ArrayList<>(n);
        for (int i = 0;i < n;i++){
            lineEdges.add(null);
        }
        E.add(lineEdges);
        V.add(new MyVertex<VItem>(vertexData));
        return n-1;
    }

    /**
     * 刪除頂點及其關聯邊，返回該頂點資訊
     * @param i
     * @return
     * 索引所對應的頂點就改變了
     */
    public VItem removeVertex(int i){
        for (int j = 0;j < n;j++){
            if(exisits(i,j)){
                removeEdge(i,j);
            }
        }
        E.remove(i);n--;//刪除第i行
        VItem vBak = V.get(i).getData();V.remove(i);//備份之後，刪除頂點i
        for (int j = 0;j < n;j++){//刪除所有入邊及第i列
            E.get(j).remove(i);
            V.get(j).setOutDegree(V.get(j).getOutDegree()-1);
        }
        return vBak;//返回被刪除頂點的資訊
    }

　　頂點新增時，我們首先需要對應的在表示邊的矩陣中新增一列和一行，因為這兩個V頂點集和E邊集是對應的，所以我們看到首先遍歷每一行，為每一行新增一個為null的邊也就是這兩個頂點間的邊還不存在，讓頂點的數量n++；再接下來，我們為這個矩陣新增一行資料，當然這一行資料存放的也全是空，因為這個新頂點還沒有與任何頂點關聯。最後我們把這個新頂點放在V集的末尾。
　　
　　此時，我們可以看到儘管我們對陣列做了這麼多動態操作，但實質上這些資料全是直接新增在陣列的最後一個位置，這個操作的時間複雜度是Ο(1)也就是常數時間。

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

　　這個是add(E e)的實際操作，我們可以看到，他首先判斷容量是否足夠，不夠就擴容，夠就直接把資料存放在最後，然後size++

　　那麼刪除時也是同理，但是刪除的時間複雜度就與他的i有關係了，因為i後面的元素需要前移，同時又因為是一個二維陣列的，這裡時間複雜度應該是Ο(n^2)，其他就是類似的操作了，這裡就不再說了。
　　
　　最後測試一下個圖是否正確

@Test
    public void testGraphBFS(){
        MyGrapMatrix<String,Integer> myGrapMatrix = new MyGrapMatrix<>();
        myGrapMatrix.insertVertex("S");
        myGrapMatrix.insertVertex("A");
        myGrapMatrix.insertVertex("D");
        myGrapMatrix.insertVertex("E");
        myGrapMatrix.insertVertex("C");
        myGrapMatrix.insertVertex("B");
        myGrapMatrix.insertVertex("F");
        myGrapMatrix.insertVertex("G");
        myGrapMatrix.insertEdge(1,1,0,1);
        myGrapMatrix.insertEdge(1,1,0,4);
        myGrapMatrix.insertEdge(1,1,0,2);
        myGrapMatrix.insertEdge(1,1,1,0);
        myGrapMatrix.insertEdge(1,1,1,4);
        myGrapMatrix.insertEdge(1,1,1,3);
        myGrapMatrix.insertEdge(1,1,2,0);
        myGrapMatrix.insertEdge(1,1,2,5);
        myGrapMatrix.insertEdge(1,1,3,1);
        myGrapMatrix.insertEdge(1,1,3,6);
        myGrapMatrix.insertEdge(1,1,3,7);
        myGrapMatrix.insertEdge(1,1,4,0);
        myGrapMatrix.insertEdge(1,1,4,1);
        myGrapMatrix.insertEdge(1,1,4,5);
        myGrapMatrix.insertEdge(1,1,5,2);
        myGrapMatrix.insertEdge(1,1,5,4);
        myGrapMatrix.insertEdge(1,1,6,3);
        myGrapMatrix.insertEdge(1,1,6,7);
        myGrapMatrix.insertEdge(1,1,7,3);
        myGrapMatrix.insertEdge(1,1,7,5);
        myGrapMatrix.insertEdge(1,1,7,6);
        System.out.println(myGrapMatrix.getVertexNum());
        System.out.println(myGrapMatrix.getEdgeNum());
        myGrapMatrix.BFS(0);
    }

　　執行結果
　　
　　這裡同時測試了樹的BFS，確實我們完成樹的同時也順便完成樹的DFS和BFS，這些東西，以後再說。

相關推薦

使用鄰接矩陣實現圖結構

　　關於圖的一些特點就不說了，現在我們先展示的是頂點的實現 /** * Created by 西皮 on 2017/9/15 19:58. * 圖的頂點類 */ public class MyVertex<VItem> { pri

資料結構-基於鄰接矩陣實現圖的遍歷視覺化及使用Floyd、Dijkstra演算法求解最短路徑（JavaScript實現）

使用 JavaScript 基於鄰接矩陣實現了圖的深度、廣度遍歷，以及 Floyd、Dijkstra 演算法求解最短路徑。另外使用 SVG 實現圖的遍歷視覺化。一、輸入首先，輸入資料主要有兩個，一個是存放節點名的陣列，另一個是存放邊物件的陣列。例如：//存放圖結點的陣列 va

鄰接矩陣實現圖論的相關算法

mcs lower 鄰接矩陣 following blank tar owin 實現圖 鄰接矩陣實現圖 766I酒腫1M卻蹬橢1http://www.facebolw.com/space/2103927/following 11mGOE揭嶄9QGX潭http://www.f

資料結構(C++)——圖：基於鄰接矩陣實現的圖結構

抽象資料型別 操作介面：圖支援的操作介面分為邊和頂點兩類 Graph模板類 typedef enum { UNDISCOVERED, DISCOVERED, VISITED } VStatus; //頂點狀態 typedef enum { UNDETERMINE

資料結構基礎 之 圖 的 鄰接矩陣實現與鄰接表實現

【鄰接矩陣】 鄰接矩陣，就是一個反應邊與邊之間聯絡的二維陣列。這個二維陣列我們用matrix[numV][numV]表示，其中numV是頂點數。 對於無權圖 若頂點Vi和Vj之間有邊，則matrix[Vi][Vj]=1;否則matrix[Vi][Vj]=0。 對

圖的鄰接矩陣存儲結構

data error 對角線 一個 () num out == using 如上圖。我們能夠把v0標記為0。v1標記為1。。。。 並把聯通的2點權值全設置為1，那麽能夠用鄰接矩陣（右圖）來表示 概念解析： 第一個鄰接頂點： 我們以vo為

15 圖-圖的遍歷-基於鄰接矩陣實現的BFS與DFS算法

namespace 可能 鄰接矩陣 != pre 圖的遍歷 std amp 無法 算法分析和具體步驟解說直接寫在代碼註釋上了 TvT 沒時間了等下還要去洗衣服 就先不贅述了 有不明白的歡迎留言交流！（估計是沒人看的了） 直接上代碼： 1 #include<

鄰接矩陣存圖及遍歷——————資料結構作業

實現 鄰接矩陣存圖 DFS遞迴遍歷 DFS非遞迴遍歷 BFS遞迴遍歷 #include<cstdio> #include<cstring> #include<queue> #include<stack>

圖 ADT介面 遍歷運算 常規運算 鄰接矩陣實現

Graph.h   (圖的結構, 遍歷, 常規操作介面) 1 /*定義圖的最大定點數, 它要大於等於具體圖的頂點樹n*/ 2 #define MaxVertexNum 12 3 4 /*定義圖的最大邊數,它要大於等於具體圖的邊數e*/ 5 #define MaxEdgeNum 2

資料結構——PTA 鄰接矩陣儲存圖的深度優先遍歷、鄰接表儲存圖的廣度優先遍歷

廣度優先與深度優先是遍歷圖的兩種基本方法，大致的思想是DFS為遞迴，而BFS是佇列。 這裡給出PTA兩道題目的答案，方法很基本，但第三個形參還是第一次見，去網上搜了搜給出的說法是呼叫函式的地址，但個人感覺就是呼叫這個函式。。。 下面給出兩段程式碼 void BFS ( LGraph

Kruskal演算法實現最小生成樹（鄰接矩陣儲存圖）

程式碼如下： #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 typedef struct { int u; int v; int w; }Edges; void Bubblesort(

Prim演算法實現最小生成樹（鄰接矩陣儲存圖）

程式碼如下 #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 typedef struct { int vertex[MAXSIZE]; int edges[MAXSIZE][MAXSIZE];

資料結構 鄰接矩陣儲存圖的深度優先遍歷

練習6.1 鄰接矩陣儲存圖的深度優先遍歷 （20 point(s)） 試實現鄰接矩陣儲存圖的深度優先遍歷。 函式介面定義： void DFS( MGraph Graph, Vertex V, void (*Visit)(Vertex) ); 其中MGraph是鄰

C語言用DFS實現找到圖的所有路徑（鄰接矩陣實現）

以下是例子，所有圖的DFS遍歷，只需要修改createGraphics()函式即可，即生成自己的map（鄰接矩陣）,就可以找到兩個點之間所有的路徑。 1.問題如下： 輸入一個矩陣的行數r（5-10）與列數c（5-10），生成一個無向圖,該圖每行有c個頂點每列有r個頂點

圖的廣度優先遍歷BFS（鄰接矩陣實現）c語言

廣度優先遍歷也叫廣度優先搜尋(Breadth First Search)。它的遍歷規則：先訪問完當前頂點的所有鄰接點。先訪問的頂點的鄰接點先於後訪問頂點的鄰接點被訪問。演算法思想：使用佇列的資料結構（FIFO （First In First Out）），將一個頂點加入佇列，然

資料結構-基於鄰接表實現圖的遍歷視覺化及使用Floyd、Dijkstra演算法求解最短路徑（JavaScript實現）

使用 JavaScript 基於鄰接表實現了圖的深度、廣度遍歷，以及 Floyd、Dijkstra 演算法求解最短路徑。另外使用 SVG 實現圖的遍歷視覺化。<!DOCTYPE html> <html lang="en"> <head>

鄰接矩陣儲存圖Java實現

import java.util.Scanner; /** * 鄰接矩陣儲存的圖 * @author liangxiamoyi * */ public class Graph_Matrix { /** * 圖中最大頂點個數 */ public stat

資料結構 鄰接矩陣儲存圖的深度優先遍歷

練習6.1 鄰接矩陣儲存圖的深度優先遍歷 （20 point(s)） 試實現鄰接矩陣儲存圖的深度優先遍歷。 函式介面定義： void DFS( MGraph Graph, Vertex V, void (*Visit)(Vertex) ); 其中MGraph是鄰接矩

【資料結構】以鄰接矩陣作儲存結構，求連通分量的個數，設計演算法求圖G的深度，深度優先序列輸出

#include <iostream> #define MaxVerNum 100 typedef char ElemType; using namespace std; typedef struct { ElemType vexs[MaxV

鄰接矩陣實現無向圖的建立

#include<stdio.h> #define Maxsize 50 #define M 5000//定義無窮數值為5000 typedef struct { char vex[Maxsize];//頂點表 int arc[Maxsize][Maxsiz