数据结构与算法基础（王卓）（22）：关于图的创建与解构剖析（用邻接矩阵表示图）

前置条件：

#include<iostream>
using namespace std;

typedef int Status;
#define MaxInt 999999  //表示无穷大
#define MVNum 100  //最大顶点数
//MAX Vertex Number
typedef char VertexType;  //设顶点类型：字符型
typedef int ArcType;  //设边的权值类型：int型

struct AMG
{
    VertexType vex[MVNum];  //顶点表
    ArcType arc[MVNum][MVNum];  //邻接矩阵
    int VexNum, ArcNum;  //（图）当前：顶点数和边数
};  //Adjacency Matrix Graph

Adjacency：

接（邻）近；毗邻；相邻性；邻接（物）；邻近距离;

无向图构造：

创建无向图：

函数体：

Status CreateUDN(AMG& G)
//Un Directed Net
{
    cout << "input num" << endl;
    cin >> G.VexNum >> G.ArcNum;

    cout << "input vexs" << endl;
    for (int i = 0; i <= G.VexNum; i++)
        cin >> G.vex[i];

    //数组不是从零开始吗，那不是多了一个位置
    
    for (int j = 0; j <= G.ArcNum; j++)
        for (int k = 0; k <= G.ArcNum; k++)
            G.arc[j][k] = MaxInt;

    //构建邻接矩阵
    for (int k = 0; k < G.ArcNum; k++) 
    {
        int weight;
        VertexType v1, v2;
        cin >> v1 >> v2 >> weight;  //输入一条边依附的顶点和边的权值
        int i = LocateVex(G, v1);  //确定v1在G中的位置
        int j = LocateVex(G, v2);  //确定v2在G中的位置
        G.arc[i][j] = weight;  //邻接矩阵赋值
        G.arc[j][i] = G.arc[i][j];  //无向图，反过来值相同
    }
    return true;
}

自己写的：（【构建邻接矩阵，把每条边的权值都输入到矩阵当中】的模块）

    for (int m = 0; m <= G.ArcNum; m++)
        //逐个输入每一条边
    {
        int weight;
        VertexType v1, v2;
        cin >> v1 >> v2 >> weight;
        int a, b;
        a = LocateVexNumber(G, v1);
        b = LocateVexNumber(G, v2);
        G.arc[a][b] =G.arc[b][a]= weight;
    }

LocateVex(G, v)函数：

Status LocateVex(AMG &G, VertexType& v)
{
    for (int i = 0; i < G.VexNum; ++i)
    {
        if (G.vex[i] == v)
            return i;
    }
    return -1;
}

注意：

别忘了写 

    return -1;

！！！ 

问题：

    //数组不是从零开始吗，那不是多了一个位置

无向网、有向网、有向图： 

 简而言之，就是修改【构造邻接矩阵】的程序：

无向网：

    //构造邻接矩阵
    for (int k = 0; k < G.ArcNum; k++) 
    {
        //int weight;
        VertexType v1, v2;
        cin >> v1 >> v2;//>> weight;  //输入一条边依附的顶点和边的权值
        int i = LocateVex(G, v1);  //确定v1在G中的位置
        int j = LocateVex(G, v2);  //确定v2在G中的位置
        G.arc[i][j] = 1;// weight;  //邻接矩阵赋值
        G.arc[j][i] = G.arc[i][j];  //无向图，反过来值相同
    }

有向网：

    //构建邻接矩阵
    for (int k = 0; k < G.ArcNum; k++) 
    {
        int weight;
        VertexType v1, v2;
        cin >> v1 >> v2 >> weight;  //输入一条边依附的顶点和边的权值
        int i = LocateVex(G, v1);  //确定v1在G中的位置
        int j = LocateVex(G, v2);  //确定v2在G中的位置
        G.arc[i][j] = weight;  //邻接矩阵赋值
        //G.arc[j][i] = G.arc[i][j];  //无向图，反过来值相同
    }

有向图： 

    //构造邻接矩阵
    for (int k = 0; k < G.ArcNum; k++)
    {
        //int weight;
        VertexType v1, v2;
        cin >> v1 >> v2;//>> weight;  //输入一条边依附的顶点和边的权值
        int i = LocateVex(G, v1);  //确定v1在G中的位置
        int j = LocateVex(G, v2);  //确定v2在G中的位置
        G.arc[i][j] = 1;// weight;  //邻接矩阵赋值
        //G.arc[j][i] = G.arc[i][j];  //无向图，反过来值相同
    }

附加：

爪型行列式：除第一行第一列还有对角线，其余元素为零的

实际上，根据结构的稀疏性，像无向网之类的我们一般都用链式存储，链式存储的介绍看下一篇文章/日记即可