图——图的邻接矩阵存储结构

1，基本思想： 

       1，用一维数组存储顶点：描述顶点相关的数据；

       2，用二维数组存储边：描述顶点间的关系和权；

      

2，邻接矩阵法（二维数组存储权值表示边）：

       1，设图 A = (V, E) 是一个有 n 个顶点的图，图的邻接矩阵为 Edge[n][n]，则：

 

       2，解决工程问题时，习惯于对图中的每个顶点进行编号，当不需要权值时，取 w 非空表示结点间有连接；

       3，无向图的邻接矩阵是对称的，有向图的邻接矩阵可能不是对称的；

      

3，邻接矩阵设计与实现：

 

       1，如何具体表示顶点集数组？

       2，如何具体表示边集数组？

      

4，实现方式一：直接使用数组表示顶点集和边集：

       

       1，将邻接矩阵直接搬到代码中，这种方法不科学；

       2，分析下面代码的效率：

           

              1，构造效率低下：

                     1，图对象初始化时，频繁调用顶点类型和边类型的构造函数；

              2，空间使用率低下：

                     1，图对象占用大量空间，而大多数空间处于闲置状态；

              3，无法表示空值：

                     1，无法用统一的方式表示边为空的情形；

   

5，实现方式二：使用指针数组表示顶点集和边集：

     

       1，构造效率：

              1，初始化图对象时，只需要将数组元素赋值为空，不需要调用顶点类型       和边类型的构造函数；

              2，空间使用率：

                     1，顶点数据元素和边数据元素在需要时动态创建；

              3，空值的表示：

                     1，任意的顶点类型和边类型都是用 NULL 表示空值；

6，图的邻接矩阵结构：

#ifndef MATRIXGRAPH_H
#define MATRIXGRAPH_H

#include "Graph.h"
#include "Exception.h"
#include "DynamicArray.h"

namespace DTLib
{

/* MatirxGraph 无法动态 添加/删除 顶点，图对象空间利用率低。不管顶点是否连接，都会占用空间，使用数组浪费空间，用链表替换数组，将邻接矩阵换为邻接链表法；适用于内存资源富足场合 */
template < int N, typename V, typename E >  // N 是图中顶点个数，V 是与顶点相关的数据类型，E 是权值的类型；
class MatrixGraph : public Graph<V, E>
{
protected:
    V* m_vertexes[N];  // 每个成员都是指向顶点的相关联的数据元素的指针，这里的数据是工程需要、工程相关的背景；
    E* m_edges[N][N];  // 邻接矩阵
　　 int m_eCount;  // 当前图中边的个数

public:
    MatrixGraph()
    {
        for(int i=0; i<vCount(); i++)  // 指针数组初始化
        {
            m_vertexes[i] = NULL;  // 没有一个数据元素和顶点相关联
            for(int j=0; j<vCount(); j++)
            {
                m_edges[i][j] = NULL;  // 一条边也没有
            }
        }

        m_eCount = 0;
　　 }

    /* 获取和顶点 i 相关联的元素的值 */
    V getVertex(int i)  // O(1)
    {
        V ret;

        if( !getVertex(i, ret) )
        {
            THROW_EXCEPTION(InvalidParameterException, "Index i is invalid ...");
        }

        return ret;
　　 }

    /* 获取顶点 i 所关联的元素值 value */
    bool getVertex(int i, V& value)  // O(1)
    {
        bool ret = ( (0 <= i) && (i < vCount()) );  // i 的合法性

        if( ret )
        {
            if( m_vertexes[i] != NULL ) // 有具体元素关联
            {
                value = *(m_vertexes[i]);
            }
            else
            {
                THROW_EXCEPTION(InvalidOperationException, "No value assigned to this vertex ...");
            }
        }
        return ret;
　　 }

    /* 设置和顶点相关联的元素 */
    bool setVertex(int i, const V& value)  // O(1)
    {
        bool ret = ( (0 <= i) && (i < vCount()) );

        if( ret )
        {
            V* data = m_vertexes[i];  // 中间数据 data 为了异常安全

            if( data == NULL )  // 没有具体元素关联
            {
                data = new V();
            }

            if( data != NULL )  // 申请成功
            {
                *data = value;  // 设置值，单位和要加指针？如果这里发生异常安全，则下面代码不执行，图还是正常的

                m_vertexes[i] = data;
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to store new vertex value ...");
            }
        }

        return ret;
　　 }

    /* 获取从 i 作为起点的可达的顶点的编号，到数组中 */
    SharedPointer< Array<int> > getAdgacent(int i)  // O(n)
    {
        DynamicArray<int>* ret = NULL;  // 定义返回值对象

        if( (0 <= i) && (i < vCount()) )  // i 取值要合法
        {
            int n = 0;

            for(int j=0; j<vCount(); j++)  // 查找 i 行关联点
            {
                if( m_edges[i][j] != NULL )  // 顶点 i 和 j 相关联
                {
                    n++;  // n 表示与 i 相关联的顶点个数
                }
            }

            ret = new DynamicArray<int>(n);  // 创建返回值对象

            if( ret != NULL )  // 创建成功
            {
                for(int j=0, k=0; j<vCount(); j++)  // k 作为辅助变量
                {
                    if( m_edges[i][j] != NULL )
                    {
                        ret->set(k++, j);  // 记录对应的顶点编号到数组对象中
                    }
                }
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create ret object ...");
            }
        }
        else
        {
            THROW_EXCEPTION(InvalidParameterException, "Index i is invalid ...");
        }

        return ret;
　　 }

    /* 判断 i 到 j 顶点边是否连接，值不为空就连接 */
    bool isAdjacent(int i, int j)
    {
        return (0 <= i) && (i < vCount()) && (0 <= j) && (j < vCount()) && (m_edges[i][j] != NULL);
　　 }

    /* 获取顶点 i 到顶点 j 边上面的权值 */
    E getEdge(int i, int j)  // O(1)
    {
        E ret;

        if( !getEdge(i, j, ret) )  // 直接获得值
        {
            THROW_EXCEPTION(InvalidParameterException, "Index <i, j> is invalid ...");
        }

        return ret;
　　 }

    /* 获取顶点 i 到顶点 j 边上面的权值 */
    bool getEdge(int i, int j, E& value)  // O(1)
    {
        bool ret = ( (0 <= i) && (i < vCount()) &&
                     (0 <= j) && (j < vCount()) );  // i,j 的合法性

        if( ret )
        {
            if( m_edges[i][j] != NULL ) // 权值存在，可以拿到
            {
                value = *(m_edges[i][j]);  // 获取元素，这里面存储的是指针，所以要加 *
            }
            else
            {
                THROW_EXCEPTION(InvalidOperationException, "No value assigened to this edge ...");
            }
        }

        return ret;
　　 }

    /* 设置边上面权值的操作 */
    bool setEdge(int i, int j, const E& value)  // O(1)
    {
        bool ret = ( (0 <= i) && (i < vCount()) &&
                     (0 <= j) && (j < vCount()) );  // i,j 的合法性

        if( ret )
        {
            E* ne = m_edges[i][j];  // 使用中间变量

            if( ne == NULL )  // i 到 j 本来不可达
            {
                ne = new E();  // 创建可达对象，设置 i 到 j 的连接

                if( ne != NULL )  // 创建成功
                {
                    *ne = value;  // 设置权值
                    m_edges[i][j] = ne;  // i 到 j 是可达的
                    m_eCount++;  // 边数加 1
                }
                else
                {
                    THROW_EXCEPTION(NoEnoughMemoryException, "No memory to store new edge value ...");
                }
            }
            else
            {
                *ne = value;  // 改变权值
            }
        }

        return ret;
　　 }

    /* 删除 i 和 j 之间的关联，即没有边了 */
    bool removeEdge(int i, int j)  // O(1)
    {
        bool ret = ( (0 <= i) && (i < vCount()) &&
                     (0 <= j) && (j < vCount()) );  // i,j 的合法性

        if( ret )
        {
            E* toDel = m_edges[i][j];  // 定义中间变量指针指向要删除的权值对象
            m_edges[i][j] = NULL;  // 中间指针指向要删除的对象了，将邻接矩阵对应元素赋为空值

            if( toDel != NULL )
            {
                m_eCount--;  // 边个数减一
                delete toDel; // 为了尽量的达到异常安全目的，释放 m_edges 所指向的对象；
            }
        }

        return ret;
　　 }

    /* 获取当前图中顶点的数量 */
    int vCount()  // O(1)
    {
        return N;  // 顶点的数量为当前模板参数 N，顶点数量是一个定制；
　　 }

    /* 获取当前图中边的数量 */
    int eCount()  // O(1)
    {
       return m_eCount;  // 添加边和删除边其都相应的变化
　　 }

    /* 顶点 i 的出度，i 行不为 0 的个数 */
    int OD(int i)  // O(n)
    {
        int ret = 0;
        if( (0 <= i) && (i < vCount()) )
        {
            for(int j=0; j<vCount(); j++)  // 数邻接矩阵对应的行中有多少个不为 0 的个数
            {
                if( m_edges[i][j] != NULL ) // 第 i 行不为 0
                {
                    ret++;
                }
            }
        }
        else
        {
            THROW_EXCEPTION(InvalidParameterException, "Index i is invalid ...");
        }

        return ret;
　　 }

    /* 顶点 i 的入度，i 列不为 0 的个数 */
    int ID(int i)  // O(n)
    {
        int ret = 0;

        if( (0 <= i) && (i < vCount()) )
        {
            for(int j=0; j<vCount(); j++)  // 数邻接矩阵对应的列中有多少个不为 0 的个数
            {
                if( m_edges[j][i] != NULL ) // 第 i 列不为 0
                {
                    ret++;
                }
            }
        }
        else
        {
            THROW_EXCEPTION(InvalidParameterException, "Index i is invalid ...");
        }

        return ret;
　　 }


    ~MatrixGraph()  // O(n*n)
    {
        for(int i=0; i<vCount(); i++)  // 指针数组初始化
        {
            for(int j=0; j<vCount(); j++)
            {
                delete m_edges[i][j];  // 销毁每条边
            }

            delete m_vertexes[i] ;  // 销毁和每个顶点相关联的数据元素
        }
    }
};

}

#endif // MATRIXGRAPH_H

                    

7，图的邻接矩阵结构实现测试代码：

#include <iostream>
#include "MatrixGraph.h"

using namespace std;
using namespace DTLib;

int main()
{
　　 MatrixGraph<3, int, int> g;

    g.setEdge(0, 1, 1);
    g.setEdge(1, 0, 2);
    g.setEdge(1, 2, 3);

    cout << "vCount: " << g.vCount() << endl;
    cout << "eCount: " << g.eCoutn() << endl;

    cout << "ID(1): " << g.ID(1) << endl;
    cout << "OD(1): " << g.OD(1) << endl;
    cout << "TD(1): " << g.TD(1) << endl;

    cout << "W(0, 1): " << g.getEdge(0, 1) << endl;
    cout << "W(1, 0): " << g.getEdge(1, 0) << endl;
    cout << "W(1, 2): " << g.getEdge(1, 2) << endl;

    SharedPointer< Array<int> > aj = g.getAdgacent(2);

    for(int i=0; i<aj->length(); i++)
    {
        cout << (*aj)[i] << " ";
    }

    cout << endl;

    cout << "Delete Edge: " << endl;

    g.removeEdge(0, 1);

    cout << "eCount: " << g.eCoutn() << endl;

    g.setVertex(0, 100);

    cout << "V(0): " << g.getVertex(0) << endl;

    //cout << "W(0, 1): " << g.getEdge(0, 1) << endl;  // 非法操作

    return 0;
}

8，小结：

       1，邻接矩阵法使用数组对图相关的数据进行存储；

       2，一维数组存储顶点相关的数据（空表示无相关的数据）；

       3，二维数组存储边相关的数据（空表示顶点间无连接）；

       4，代码实现时使用指针数组进行数据的存储（提高效率）；