2. 程式人生 > >圖的鄰接矩陣與鄰接表儲存方式及優缺點對比

圖的鄰接矩陣與鄰接表儲存方式及優缺點對比

阿新 • • 發佈：2019-01-06

概述

記錄一些圖的基本概念，以及圖的兩種表示方式（鄰接表和鄰接矩陣）的程式碼實現，最後總結了兩種方式的優缺點，還簡單介紹了十字連結串列和逆鄰接表。

圖的部分基本概念（我記不住的）

1、完全圖

一個無向圖，任意兩個頂點之間有且僅有一條邊，則稱為無向完全圖。若一個無向完全圖有 n 個頂點，那麼它就有 n∗(n−1)/2 條邊。
一個有向圖，任意兩個頂點之間有且僅有方向相反的兩條邊，則稱為有向完全圖。若一個有向完全圖有 n 個頂點，那麼它就有 n∗(n−1) 條邊。

2、鄰接頂點

在無向圖中，頂點 u 與 v 之間有一條邊（u，v），則稱 u 和 v 互為鄰接頂點。
在有向圖

中，頂點 u 和 v 之間有一條邊<u, v>，則頂點 u 鄰接到頂點 v，頂點 v 鄰接自頂點 u，並稱邊<u，v>與頂點 u、v 相關聯。

3、頂點的度

頂點的度就是與它相關聯的邊的條數，入度表示邊的終點指向頂點的個數，出度表示邊的起點指向頂點的個數。

在有向圖中，頂點的度等於入度與出度的和。

在無向圖中，頂點的度 =入度 = 出度。

4、連通圖：

在無向圖中，兩個頂點之間有路徑，則稱這兩個頂點是連通的。如果如中任意一對頂點都是連通的，則稱此圖為連通圖。

在有向圖中，若任意一對頂點 vi 和 vj，都有從 vi 到 vj 的路徑，則稱此圖為強連通圖。

5、生成樹：

一個連通圖（無向圖）的最小子圖稱為該圖的生成樹。有 n 個頂點的連通圖的生成樹有 n - 1 條邊。最小生成樹就是權值和最小的生成樹。

鄰接矩陣表示法

在一個一維陣列中儲存所有的點，在一個二維陣列中儲存頂點之間的邊的權值，以及一個布林值標記是否是有向圖，預設是無向圖：

    bool        isDirected;  // 標識是否是有向圖，預設為false
    vector<V>       vertex;  // 儲存頂點
    vector<vector<W> > edge; // 儲存邊

graph.h

#ifndef GRAPH_H
 

#define GRAPH_H

#include <vector>
#include <cassert>
#include <iostream>
using namespace std;

// V -- 圖頂點的資料型別
// W -- 圖邊權值的型別
template <typename V, typename W>
class GraphMatrix
{
public:
    GraphMatrix(const V* _vertex, size_t _size, bool _isDirected = false);

    // 列印圖中的所有邊
    void printEdge();
    // 向圖中新增一條邊
    void addEdge(const V& v1, const V& v2, const W& weight);

private:
    // 獲取邊所在的下標
    int getIndexOfVertex(const V& _vertex);

private:
    bool        isDirected;  // 標識是否是有向圖，預設為false
    vector<V>       vertex;  // 儲存頂點
    vector<vector<W> > edge; // 儲存邊

};

#endif //GRAPH_H

graph.cpp

#include "graph.h"


/*
*   public 函式
*/

template<typename V, typename W>
GraphMatrix<V,W>::GraphMatrix(const V* _vertex, size_t _size, bool _isDirected = false)
{
    // 開闢空間並初始化資料
    this->vertex.resize(_size);
    this->edge.resize(_size);
    this->isDirected = _isDirected;

    for (int idx = 0; idx < _size; ++idx)
    {
        this->vertex[idx] = _vertex[idx];
        this->edge[idx].resize(_size);
    }
}

template<typename V, typename W>
void GraphMatrix<V, W>::addEdge(const V& v1, const V& v2, const W& weight)
{
    int start = getIndexOfVertex(v1);
    int end = getIndexOfVertex(v2);

    edge[start][end] = weight;

    // 如果是無向圖還需要新增對稱的一遍
    if (!isDirected)
        edge[end][start] = weight;
}

template<typename V, typename W>
void GraphMatrix<V, W>::printEdge()
{
    for (int idx = 0; idx < vertex.size(); ++idx)
        cout <<  "" <<  vertex[idx];
    cout << endl;

    for (int idx_row = 0; idx_row < edge.size(); ++idx_row)
    {
        cout << vertex[idx_row] << " ";
        for (int idx_col = 0; idx_col < edge.size(); ++idx_col)
        {
            cout <<  " " << edge[idx_row][idx_col] ;
        }
        cout << endl;
    }
    cout << endl;
}

/*
*   private 函式
*/

template<typename V, typename W>
int GraphMatrix<V, W>::getIndexOfVertex(const V& v)
{
    for (int idx = 0; idx < vertex.size(); idx++)
    {
        if (vertex[idx] == v)
            return idx;
    }

    // 如果沒有找到就說明發生了錯誤
    assert(false);
    return -1;
}

test.cpp

#include "graph.cpp"

#include <string>
#include <vector>
#include <iostream>
using namespace std;

void TestGraphMatrix()
{
    // 無向圖
    const char* str = "ABCDE";
    GraphMatrix<char, int> graph(str, strlen(str));
    graph.addEdge('A', 'D', 8);
    graph.addEdge('A', 'E', 9);
    graph.addEdge('B', 'E', 2);
    graph.addEdge('A', 'B', 6);
    graph.printEdge();

    cout << "--------------------------------" << endl;

    // 有向圖
    GraphMatrix<char, int> graph1(str, strlen(str), true);
    graph1.addEdge('A', 'D', 8);
    graph1.addEdge('A', 'E', 9);
    graph1.addEdge('B', 'E', 2);
    graph1.addEdge('E', 'C', 6);
    graph1.printEdge();


}

int main()
{
    TestGraphMatrix();
    return 0;
}

輸出結果：

  A B C D E
A 0 6 0 8 9
B 6 0 0 0 2
C 0 0 0 0 0
D 8 0 0 0 0
E 9 2 0 0 0

-----------

  A B C D E
A 0 0 0 8 9
B 0 0 0 0 2
C 0 0 0 0 0
D 0 0 0 0 0
E 0 0 6 0 0

鄰接表表示法

鄰接表是把頂點之間的邊當做連結串列上的結點，其中邊結點資料成員有：

  • 起點的索引
  • 終點的索引
  • 邊所在權值
  • 指向下一個結點的指標
// W -- 邊對應權值的型別
template <typename W>
struct EdgeNode
{
    W                weight;  // 邊所對應權值
    unsigned int startIndex;  // 邊起點的索引
    unsigned int   endIndex;  // 邊終點的索引
    EdgeNode<W>*   nextNode;  // 指向下個結點
};

用一個一維陣列來儲存所有的頂點。一個一維陣列來儲存頂點所對應的連結串列的頭指標（結點表示以當前頂點為起點的邊）。

bool                isDirected; 
vector<V>               vertex; // 儲存所有頂點
vector<EdgeNode<W>*> linkTable; // 儲存頂點的邊

graph.h

#ifndef GRAPH_H
#define GRAPH_H

#include <vector>
#include <cassert>
#include <iostream>
using namespace std;

// W -- 邊對應權值的型別
template <typename W>
struct EdgeNode
{
    W                weight;  // 邊所對應權值
    size_t startIndex;  // 邊起點的索引
    size_t   endIndex;  // 邊終點的索引
    EdgeNode<W>*   nextNode;  // 指向下個結點
    EdgeNode(size_t start, size_t end, const W& _weight)
        : startIndex(start)
        , endIndex(end)
        , weight(_weight)
    {}
};

// V -- 圖頂點的資料型別
// W -- 圖邊權值的型別
template <typename V, typename W>
class GraphLink
{
public:
    typedef EdgeNode<W> node;

    GraphLink(const V* _vertex, size_t _size, bool _isDirected = false);
    // 列印圖中的邊
    void printEdge();
    // 向圖中新增一條邊
    void addEdge(const V& v1, const V& v2, const W& weight);

private:
    // 獲取頂點所在索引
    size_t getIndexOfVertex(const V& v);
    // 新增一條邊
    void __addEdge(size_t startIndex, size_t endIndex, const W& weight);

private:
    bool         isDirected; 
    vector<V>        vertex; // 儲存所有頂點
    vector<node*> linkTable; // 儲存頂點的邊
};


#endif //GRAPH_H

graph.cpp

#include "graph.h"


/*
*   public 函式
*/

template<typename V, typename W>
GraphLink<V, W>::GraphLink(const V* _vertex, size_t _size, bool _isDirected)
{
    // 開闢空間並初始化資料
    this->vertex.resize(_size);
    this->linkTable.resize(_size);
    this->isDirected = _isDirected;

    for (size_t i = 0; i < _size; i++)
    {
        this->vertex[i] = _vertex[i];
    }
}

template<typename V, typename W>
void GraphLink<V, W>::printEdge()
{
    for (size_t idx = 0; idx < vertex.size(); ++idx)
    {
        cout << vertex[idx] << ": ";

        node* pEdge = linkTable[idx];
        while (pEdge)
        {
            cout << pEdge->weight << "[" << vertex[pEdge->endIndex] << "]-->";
            pEdge = pEdge->nextNode;
        }
        cout << "NULL" << endl;
    }
    cout << endl;
}

template<typename V, typename W>
void GraphLink<V, W>::addEdge(const V& v1, const V& v2, const W& weight)
{
    size_t startIndex = getIndexOfVertex(v1);
    size_t endIndex   = getIndexOfVertex(v2);

    // 防止填加自己指向自己的邊
    assert( startIndex!=endIndex);

    __addEdge(startIndex, endIndex, weight);

    // 無向圖需要新增對稱的一條邊
    if (!isDirected)
        __addEdge(endIndex, startIndex, weight);

}



/*
*   private 函式
*/



template <typename V, typename W>
void GraphLink<V, W>::__addEdge(size_t startIndex, size_t endIndex, const W& weight)
{
    // 頭插的方式新增邊到連結串列中
    node* pNewEdge = new node(startIndex, endIndex, weight);
    pNewEdge->nextNode = linkTable[startIndex];
    linkTable[startIndex] = pNewEdge;
}

template<typename V, typename W>
size_t GraphLink<V, W>::getIndexOfVertex(const V& v)
{
    for (int idx = 0; idx < vertex.size(); idx++)
    {
        if (vertex[idx] == v)
            return idx;
    }

    // 如果沒有找到就說明發生了錯誤
    assert(false);
    return -1;
}

test.cpp

#include "graph.cpp"
#include <string>
#include <vector>
#include <iostream>
using namespace std;


void TestGraphLink()
{
    // 無向圖
    char* str = "ABCDE";
    GraphLink<char, int> graph1(str, strlen(str)); 
    graph1.addEdge('A', 'C', 2);
    graph1.addEdge('D', 'B', 6);
    graph1.addEdge('A', 'B', 4);
    graph1.addEdge('E', 'D', 9);
    graph1.printEdge();

    cout << "------------" << endl;
    // 有向圖

    GraphLink<char, int> graph2(str, strlen(str), true);
    graph2.addEdge('D', 'C', 2);
    graph2.addEdge('B', 'E', 6);
    graph2.addEdge('A', 'D', 4);
    graph2.addEdge('E', 'D', 9);
    graph2.printEdge();
}

int main()
{

    TestGraphLink();
    return 0;
}

輸出結果：

A: 4[B]-->2[C]-->NULL
B: 4[A]-->6[D]-->NULL
C: 2[A]-->NULL
D: 9[E]-->6[B]-->NULL
E: 9[D]-->NULL

----------------------

A: 4[D]-->NULL
B: 6[E]-->NULL
C: NULL
D: 2[C]-->NULL
E: 9[D]-->NULL

總結與對比

1、在鄰接矩陣表示中，無向圖的鄰接矩陣是對稱的。矩陣中第 i 行或 第 i 列有效元素個數之和就是頂點的讀。

在有向圖中 第 i 行有效元素個數之和是頂點的出度，第 i 列有效元素個數之和是頂點的入度。

2、在鄰接表的表示中，無向圖的同一條邊在鄰接表中儲存的兩次。如果想要知道頂點的讀，只需要求出所對應連結串列的結點個數即可。

有向圖中每條邊在鄰接表中只出現一此，求頂點的出度只需要遍歷所對應連結串列即可。求出度則需要遍歷其他頂點的連結串列。

3、鄰接矩陣與鄰接表優缺點：

鄰接矩陣的優點是可以快速判斷兩個頂點之間是否存在邊，可以快速新增邊或者刪除邊。而其缺點是如果頂點之間的邊比較少，會比較浪費空間。因為是一個 n∗n 的矩陣。

而鄰接表的優點是節省空間，只儲存實際存在的邊。其缺點是關注頂點的度時，就可能需要遍歷一個連結串列。還有一個缺點是，對於無向圖，如果需要刪除一條邊，就需要在兩個連結串列上查詢並刪除。

擴充套件

逆鄰接表

在鄰接表中對於有向圖有一個很大的缺陷，如果我們比較關心頂點入度那麼就需要遍歷所有連結串列。為了避免這種情況出現，我們可以採用逆鄰接表來儲存，它儲存的連結串列是別的頂點指向它。這樣就可以快速求得頂點的入度。

如何對有向圖的入度和出度都關心，那麼久可以採取十字連結串列的方式。相當於每一個頂點對應兩個連結串列，一個是它指向別的頂點，一個是別的頂點指向它。

全文完

相關推薦

圖的鄰接矩陣與鄰接表儲存方式及優缺點對比

概述 記錄一些圖的基本概念，以及圖的兩種表示方式（鄰接表和鄰接矩陣）的程式碼實現，最後總結了兩種方式的優缺點，還簡單介紹了十字連結串列和逆鄰接表。 圖的部分基本概念（我記不住的） 1、完全圖 一個無向圖，任意兩個頂點之間有且僅有一條邊，則稱為

圖的儲存結構(鄰接矩陣與鄰接表)及其C++實現

一、圖的定義 圖是由頂點的有窮非空集合和頂點之間邊的集合組成，通常表示為： 　　　　　　　　　　　　　　　　　　　G=(V，E) 其中：G表示一個圖，V是圖G中頂點的集合，E是圖G中頂點之間邊的集合。 注： 線上性表中，元素個數可以為零，稱為空表； 在樹中，結

圖的儲存結構：鄰接矩陣與鄰接表（稠密圖與稀疏圖）

稠密圖用 鄰接矩陣儲存 稀疏圖用 鄰接表儲存 原因： 鄰接表只儲存非零節點，而鄰接矩陣則要把所有的節點資訊(非零節點與零節點)都儲存下來。 稀疏圖的非零節點不多，所以選用鄰接表效率高，如果選用鄰接矩陣則效率很低，矩陣中大多數都會是零節點！ 稠密圖的非零界點多，零節點少，選

圖（鄰接矩陣與鄰接表表示法）

圖的鄰接矩陣表示法  #define MaxVertexNum 100 /* 最大頂點數設為100 */ #define INFINITY 65535 /* ∞設為雙位元組無符號整數的最大值65535*/ typedef int Vertex;

資料結構，圖的鄰接矩陣建立，鄰接矩陣與鄰接表的交換，兩種表的輸出，過程用C++實現

/* 編寫一個程式algo8-1.cpp,實現不帶權圖和帶權圖的鄰接矩陣與鄰接表的互相 轉換演算法、輸出鄰接矩陣與鄰接表的演算法，並在此基礎上設計一個程式exp8-1.cpp 實現如下功能： 1）建立如圖有向圖G的鄰接矩陣，並輸出； 2）由有向圖G的鄰接矩陣產生鄰接表，並輸

圖的基本演算法實現（鄰接矩陣與鄰接表兩種方法）

本部落格前面文章已對圖有過簡單的介紹，本文主要是重點介紹有關圖的一些具體操作與應用 一、無向圖 1 無向圖——鄰接矩陣 測試環境：VS2008 #include "stdafx.h" #include <stdlib.h> #include <m

線性表之順序表與單鏈表的區別及優缺點

這裡比較的是基於C語言實現的順序表與單鏈表，與其他語言的實現可能會有差異，但我相信語言是相通的，它們的實現機制應該也差不多。 1、What 什麼是順序表和單鏈表 ①順序表： 順序表是在計算機記憶體中以陣列的形式儲存的線性表，是指用一組地址連續的儲存單元依

redis單例、主從模式、sentinel以及叢集的配置方式及優缺點對比

redis作為一種高效的快取框架，使用是非常廣泛的，在資料儲存上，在執行時其將資料儲存在記憶體中，以實現資料的高效讀寫，並且根據定製的持久化規則不同，其會不定期的將資料持久化到硬碟中。另外相較於其他的NoSql資料庫，redis提供了非常豐富的資料結構，如dict，s

tomcat部署的三種方式及優缺點對比

Tomcat的三種部署方式： 為了演示需要，簡單建立了一個web專案tomcat_deploy ，編寫了 index.jsp 作為歡迎頁 部署方法一：將編譯成功的web專案直接放到webapps目錄中（注意是編譯成功的web專案，也可以是war包）

Redis 單例、主從模式、sentinel 以及集群的配置方式及優缺點對比（轉）

after redis使用 問題： known 不能 重新 aof left meet 摘要: redis作為一種NoSql數據庫，其提供了一種高效的緩存方案，本文則主要對其單例，主從模式，sentinel以及集群的配置方式進行說明，對比其優缺點，闡述redis作為一種

再談圖的儲存方式（鄰接矩陣，鄰接表，前向星）

1.鄰接矩陣 1.存圖思想 使用一個矩陣來描述一個圖，對於矩陣的第i行第j列的值，表示編號為i的頂點到編號為j的頂點的權值。 2.程式碼實現 // 最大頂點數 const int V = 1000

圖的儲存結構（鄰接矩陣、鄰接表、十字連結串列、鄰接多重表）詳解

上篇部落格講到，圖狀結構是非常複雜的結構，圖也是非常複雜的，所以圖的儲存就是一個非常重要的部分，因為我們不僅要表示頂點集，還要表示邊集，如何完整準確的表示圖呢，接下來，給大家講解四種圖的儲存方式。 一、鄰接矩陣法 1、定義 我們用一個二維陣列存放頂點間關係（邊或弧）的資料，這個二維陣

三種存圖方式（鄰接矩陣，鄰接表，鏈式前向星）

#include<cstdio> #include<vector> #include<cstring> #include<algorithm> #include <iostream> using namespace std; const i

C語言實現圖的鄰接矩陣和鄰接表儲存

C語言實現圖的鄰接矩陣和鄰接表儲存，其中包含如下函式： CreateMat(MatGraph &g, int A[MAXV][MAXV], int n, int e)：由邊陣列A、頂點數n和邊數e建立圖的鄰接矩陣g。 DispMat(MatGraph g)：輸出鄰接矩陣g

真題2015 無向圖採用鄰接表儲存方式，刪除邊

題目：已知無向圖採用鄰接表儲存方式，試寫出刪除邊（i，j）的演算法。 在這裡插入程式碼片 voidDeletEdge(AdjListg,inti,int j){//在用鄰接表方式儲存的無向圖g中，刪除邊(i,j) p=g[i].firstarc;pre=nul

圖的遍歷與輸出 （鄰接矩陣和鄰接表）

#include <iostream> #include <cstdio> #include "graph.h" using namespace std; int main() { freopen("data.in" , "r" , st

【第十一週】資料結構之自建演算法庫——圖及其儲存結構（鄰接矩陣、鄰接表）

#include <stdio.h> #include <malloc.h> #include "hhh.h" //功能：由一個反映圖中頂點鄰接關係的二維陣列，構造出用鄰接矩陣儲存的圖 //引數：Arr - 陣列名，由於形式引數為二維陣列時必須給出每行的元素個數，在此將引數Arr宣告

資料結構——圖—概念和儲存（鄰接矩陣，鄰接表）

圖的概念 為什麼要有圖 在學習圖之前我們應該學習了，線性表和樹；但是我們有沒有考慮過為什麼要有圖，線性表和圖的侷限性優勢上面呢？ 線性表他僅僅侷限於一個直接前驅和一個直接後繼的關係。 樹呢？樹也僅僅只能有一個直接前驅也就是父節點。 那麼這種多對

圖的儲存結構-鄰接矩陣和鄰接表

1、鄰接矩陣 圖的鄰接矩陣（Adjacency Matrix）儲存方式是用兩個陣列來表示圖。 一個一維陣列儲存圖中頂點資訊，一個二維陣列（稱為鄰接矩陣）儲存圖中的邊或弧的資訊。 設圖G有n個頂點，則鄰

圖的基本概念；圖的儲存表示：鄰接矩陣、鄰接表

無向圖 邊(vi,vj) 有向圖 弧 有向完全圖和無向完全圖 有向圖最多有n(n-1)條邊,且有n(n-1)條邊的有向圖為有向完全圖。 無向圖最多有n(n-1)/2條邊,且有n(n-1)/2條邊