图的两种存储结构及四种形态——邻接矩阵、邻接表；有向图、无向图、有向网、无向网。

声明： 代码中有大量的注释，所以此处就不再作出大量的解释了。

一 ：邻接矩阵存储结构

1.首先是各种类型与宏的定义：

#include <iostream>
using namespace std;
//无穷大
#define INFINITY INT_MAX
//最大顶点个数
#define MAX_VERTEX_NUM 20
//顶点类型
typedef char VertexType;
typedef int VRType;
typedef char infoType;
 //图的四种类型
typedef enum {DG = 1, DN, UDG, UDN} GraphKind;

//弧的结构体定义
typedef struct ArcCell
{
    // 对于网来说是权值；对于图来说就是0或1
    VRType adj;
    //该弧相关信息的指针（现在暂且可以理解为字符指针）
    infoType* info;
}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

//图的结构体定义
typedef struct
{
    VertexType vexs[MAX_VERTEX_NUM];
     //arcs可以先简单地理解为一个数组名
    AdjMatrix arcs;
    //当前图中的顶点数和弧数
    int vexnum, arcnum;
    //图的种类标志
    GraphKind kind;
}MGraph;

2.接下来是函数声明及main函数：

void CreateGraph(MGraph &G);
void CreateUDN(MGraph &G);
int LocateVex(MGraph G , int v1);
void CreateUDG(MGraph &G);
void CreateDG(MGraph &G);
void CreateDN(MGraph &G);
void Print(MGraph G);
int main(void)
{
    MGraph G;
    CreateGraph(G);
    return 0;
}

3.最后就是各种自定义函数的定义了：

void CreateGraph(MGraph &G)
{
    cout << "1、有向图" << endl;
    cout << "2、有向网" << endl;
    cout << "3、无向图" << endl;
    cout << "4、无向网" << endl;
    cout << "你需要创建哪一种类型的图?" << endl;
    //此处运用了强转（不能直接从键盘上给枚举变量赋值）
    cin >> (int&)G.kind;
    switch (G.kind)
    {
        case 1:
            return CreateDG(G);
            break;
        case 2:
            return CreateDN(G);
            break;
        case 3:
            return CreateUDG(G);
            break;
        case 4:
            return CreateUDN(G);
            break;
    }
}
//创建有向网
void CreateDN(MGraph &G)
{
    cout << "该图有多少顶点以及多少条弧?" << endl;
    cin >> G.vexnum  >> G.arcnum;
    cout << "请输入顶点:" << endl;
    for(int i = 0; i < G.vexnum; i++)
    {
        //cin相当于c里面的scanf函数
        cin >> G.vexs[i];
    }
    for(int i = 0; i < G.vexnum; i++)
    {
        for(int j = 0; j < G.vexnum; j++)
        {
            //先假设每两个点之间都没有边
            G.arcs[i][j].adj = INFINITY;
        }
    }
    cout << "请输入各弧的两个端点及其权值" << endl;
    VertexType v1, v2;
    //用于暂时存储每条弧的权值
    VRType temp;
    int i, j;
    //有向网不具备对称性
    for(int k = 0; k < G.arcnum; k++)
    {
        cin >> v1 >> v2 >> temp;
        //利用存储顶点所用的一维数组中对应点的下标
        i = LocateVex(G, v1), j = LocateVex(G, v2),
        G.arcs[i][j].adj = temp;
    }
    Print(G);
}
//创建有向图
void CreateDG(MGraph &G)
{
    cout << "该图有多少顶点以及多少条边?" << endl;
    cin >> G.vexnum  >> G.arcnum;
    cout << "请输入顶点:" << endl;
    for(int i = 0; i < G.vexnum; i++)
    {
        cin >> G.vexs[i];
    }
    for(int i = 0; i < G.vexnum; i++)
    {
        for(int j = 0; j < G.vexnum; j++)
        {
            //先假定图中没有弧
            G.arcs[i][j].adj = 0;
        }
    }
    cout << "请输入各弧的两个端点" << endl;
    VertexType v1, v2;
    //用于暂时存储每条弧的'权值'(存在即为1,否则为0)
    //因为temp的取值只能为1或0，所以不需要再输入
    VRType temp = 1;
    int i, j;
    //有向图不具备对称性
    for(int k = 0; k < G.arcnum; k++)
    {
        cin >> v1 >> v2;
        i = LocateVex(G, v1), j = LocateVex(G, v2),
        G.arcs[i][j].adj = temp;
    }
    Print(G);
}
//创建无向图（对称）
void CreateUDG(MGraph &G)
{
    cout << "该图有多少顶点以及多少条边?" << endl;
    cin >> G.vexnum  >> G.arcnum;
    cout << "请输入顶点:" << endl;
    for(int i = 0; i < G.vexnum; i++)
    {
        cin >> G.vexs[i];
    }
    for(int i = 0; i < G.vexnum; i++)
    {
        for(int j = 0; j < G.vexnum; j++)
        {
            //先假设每两个点之间都没有边
            G.arcs[i][j].adj = 0;
        }
    }
    cout << "请输入各弧的两个端点(下三角)" << endl;
    VertexType v1, v2;
    VRType temp = 1;
    int i, j;
    //考虑到无向图具有对称性（先只输入(邻接矩阵)下三角里存在的边）
    for(int k = 0; k < G.arcnum; k++)
    {
        cin >> v1 >> v2;
        i = LocateVex(G, v1), j = LocateVex(G, v2),
        G.arcs[i][j].adj = temp;
        //将上三角里的每条弧同样添加上权值
        G.arcs[j][i].adj = G.arcs[i][j].adj;
    }
    Print(G);
}
//创建无向网（对称）
void CreateUDN(MGraph &G)
{
    cout << "该图有多少顶点以及多少条边?" << endl;
    cin >> G.vexnum  >> G.arcnum;
    cout << "请输入顶点:" << endl;
    for(int i = 0; i < G.vexnum; i++)
    {
        cin >> G.vexs[i];
    }
    for(int i = 0; i < G.vexnum; i++)
    {
        for(int j = 0; j < G.vexnum; j++)
        {
            //先假设每两个点之间都没有边(无穷远)
            G.arcs[i][j].adj = INFINITY;
        }
    }
    cout << "请输入各弧的两个端点及其权值(下三角)" << endl;
    VertexType v1, v2;
    VRType temp;
    int i, j;
    //考虑到无向图具有对称性（先只输入(邻接矩阵)下三角里存在的边）
    for(int k = 0; k < G.arcnum; k++)
    {
        cin >> v1 >> v2 >> temp;
        i = LocateVex(G, v1), j = LocateVex(G, v2),
        G.arcs[i][j].adj = temp;
        //将上三角里的每条弧同样添加上权值
        G.arcs[j][i].adj = G.arcs[i][j].adj;
    }
    Print(G);
}
 //返回该顶点在一维数组中的下标（当然每一个人创建的一维数组可以是不同的）
int LocateVex(MGraph G , int v1)
{
    for(int i = 0; i < G.vexnum; i++)
    {
        if(G.vexs[i] == v1)
            return i;
    }
}
void Print(MGraph G)
{
    cout << "存储的一维数组如下:" << endl;
    for(int i = 0; i < G.vexnum; i++)
    {
        cout << G.vexs[i] << '	';
    }
    cout << endl;
    cout << "邻接矩阵如下:" << endl;
    for(int i = 0; i < G.vexnum; i++)
    {
        for(int j = 0; j < G.vexnum; j++)
        {
            cout << G.arcs[i][j].adj << '	';
        }
        cout << endl;
    }
}

二 ：邻接表存储结构

#include <iostream>
#include <string>
using namespace std;
using std :: string;
typedef string InforType;
//顶点类型
typedef char VertexType;
typedef int Status;
typedef enum {UDG = 1, DG, UDN, DN} GraphKind;
//最大顶点个数
#define MAX_VERTEX_NUM 20
#define ERROR -1
#define OK 1
//表节点的定义
typedef struct ArcNode
{
    //该弧所指向的顶点的位置（相对地址）
    int adjvex;
    //指向下一条弧的指针
    struct ArcNode* nextarc;
    //该弧相关信息的指针（例如权值）
    InforType info;
}ArcNode;
//头节点的定义
typedef struct VNode
{
    //顶点信息
    VertexType data;
    //指向第一条依附该顶点的弧的指针
    ArcNode* firstarc;
}VNode, AdjList[MAX_VERTEX_NUM];
//图的定义
typedef struct
{
    //存放头节点的一维数组
    AdjList vertices;
    //图的当前顶点数和弧数
    int vexnum, arcnum;
    //图的种类标志
    GraphKind kind;
}ALGraph;
void CreateGraph(ALGraph& G);
Status CreateUDN(ALGraph& G);
Status CreateUDG(ALGraph& G);
Status CreateDG(ALGraph& G);
Status CreateDN(ALGraph& G);
int LocateVex(VNode vertices[], int vexnum, VertexType e);
void Print(const ALGraph& G);
int main(void)
{
    ALGraph G;
    CreateGraph(G);
    return 0;
}
void CreateGraph(ALGraph& G)
{
    int reply;
    cout << "1. 无向图" << endl;
    cout << "2. 有向图" << endl;
    cout << "3. 无向网" << endl;
    cout << "4. 有向网" << endl;
    //其实逆与正是差不多的，根本上还是取决于用户的输入
    cout << "5. 逆有向网" << endl;
    cout << "6. 逆有向图" << endl;
    cout << "你想创建哪一种类型的图?" << endl;
    cin >> reply;
    switch(reply)
    {
    case 1:
        CreateUDG(G);
        break;
    case 2:
        CreateDG(G);
        break;
    case 3:
        CreateUDN(G);
        break;
    case 4:
        CreateDN(G);
        break;
    case 5:
        CreateDN(G);
        break;
    case 6:
        CreateDG(G);
        break;
    default:
        exit(-1);
    }
}
//构造无向网
Status CreateUDN(ALGraph& G)
{
    VertexType e;
    int num;
    cout << "该图共有多少个顶点、多少条弧?" << endl;
    cin >> G.vexnum >> G.arcnum;
    cout << "请输入各顶点:" << endl;
    for(int i = 0; i < G.vexnum; i++)
    {
        //注意存储结构
        cin >> G.vertices[i].data;
        //先将头节点的指针域设为空
        G.vertices[i].firstarc = NULL;
    }
    for(int i = 0; i < G.vexnum; i++)
    {
        //(强调引用)
        //注意ptr是节点的指针（是节点类型的一部分）而不是‘指向’节点的指针
        //所以接连各节点不想以前那样简单了
        ArcNode* &ptr = G.vertices[i].firstarc;
        cout << "请问以顶点" << G.vertices[i].data << "为起点的弧一共有多少条?" << endl;
        cin >> num;
        if(num > 0)
        {
            int Index;
            ArcNode* p = NULL;
            cout << "请将这些顶点及弧所带信息依次输入:" << endl;
            //先处理一个节点（为了方便后面的操作）
            ptr = new ArcNode;
            if(ptr)
            {
                cin >> e;
                //输入弧上的信息
                cin >> ptr->info;
                Index = LocateVex(G.vertices, G.vexnum, e);
                p = ptr;
                p->adjvex = Index;
                p->nextarc = NULL;
            }
            else
                return ERROR;
            for(int j = 1; j < num; j++)
            {
                ArcNode* ptr2 = new ArcNode;
                if(ptr2)
                {
                    //注意各变量的类型，不要搞混了
                    cin >> e;
                    //输入弧上的信息
                    cin >> ptr2->info;
                    Index = LocateVex(G.vertices, G.vexnum, e);
                    ptr2->adjvex = Index;
                    ptr2->nextarc = NULL;
                    //注意此处的连接节点与以前写的有点不同（ptr‘一直’为空）
                    p->nextarc = ptr2;
                    p = p->nextarc;
                }
                else
                    return ERROR;
            }
        }
    }
    Print(G);
    return OK;
}
//构造无向图
Status CreateUDG(ALGraph& G)
{
    VertexType e;
    int num;
    cout << "该图共有多少个顶点、多少条弧?" << endl;
    cin >> G.vexnum >> G.arcnum;
    cout << "请输入各顶点:" << endl;
    for(int i = 0; i < G.vexnum; i++)
    {
        //注意存储结构
        cin >> G.vertices[i].data;
        //先将头节点的指针域设为空
        G.vertices[i].firstarc = NULL;
    }
    for(int i = 0; i < G.vexnum; i++)
    {
        //(强调引用)
        //注意ptr是节点的指针（是节点类型的一部分）而不是‘指向’节点的指针
        //所以接连各节点不想以前那样简单了
        ArcNode* &ptr = G.vertices[i].firstarc;
        cout << "请问以顶点" << G.vertices[i].data << "为起点的弧一共有多少条?" << endl;
        cin >> num;
        if(num > 0)
        {
            int Index;
            ArcNode* p = NULL;
            cout << "请将这些顶点依次输入:" << endl;
            //先处理一个节点（为了方便后面的操作）
            ptr = new ArcNode;
            if(ptr)
            {
                cin >> e;
                Index = LocateVex(G.vertices, G.vexnum, e);
                p = ptr;
                p->adjvex = Index;
                p->nextarc = NULL;
            }
            else
                return ERROR;
            for(int j = 1; j < num; j++)
            {
                //注意各变量的类型，不要搞混了
                cin >> e;
                Index = LocateVex(G.vertices, G.vexnum, e);
                ArcNode* ptr2 = new ArcNode;
                if(ptr2)
                {
                    ptr2->adjvex = Index;
                    ptr2->nextarc = NULL;
                    //注意此处的连接节点与以前写的有点不同（ptr‘一直’为空）
                    p->nextarc = ptr2;
                    p = p->nextarc;
                }
                else
                    return ERROR;
            }
        }
    }
    Print(G);
    return OK;
}
//构造有向图
Status CreateDG(ALGraph& G)
{
    VertexType e;
    int num;
    cout << "该图共有多少个顶点、多少条弧?" << endl;
    cin >> G.vexnum >> G.arcnum;
    cout << "请输入各顶点:" << endl;
    for(int i = 0; i < G.vexnum; i++)
    {
        //注意存储结构
        cin >> G.vertices[i].data;
        //先将头节点的指针域设为空
        G.vertices[i].firstarc = NULL;
    }
    for(int i = 0; i < G.vexnum; i++)
    {
        //(强调引用)
        //注意ptr是节点的指针（是节点类型的一部分）而不是‘指向’节点的指针
        //所以接连各节点不想以前那样简单了
        ArcNode* &ptr = G.vertices[i].firstarc;
        cout << "请问以顶点" << G.vertices[i].data << "为起点的弧一共有多少条?" << endl;
        cin >> num;
        if(num > 0)
        {
            int Index;
            ArcNode* p = NULL;
            cout << "请将这些顶点依次输入:" << endl;
            //先处理一个节点（为了方便后面的操作）
            ptr = new ArcNode;
            if(ptr)
            {
                cin >> e;
                Index = LocateVex(G.vertices, G.vexnum, e);
                p = ptr;
                p->adjvex = Index;
                p->nextarc = NULL;
            }
            else
                return ERROR;
            for(int j = 1; j < num; j++)
            {
                //注意各变量的类型，不要搞混了
                cin >> e;
                Index = LocateVex(G.vertices, G.vexnum, e);
                ArcNode* ptr2 = new ArcNode;
                if(ptr2)
                {
                    ptr2->adjvex = Index;
                    ptr2->nextarc = NULL;
                    //注意此处的连接节点与以前写的有点不同（ptr‘一直’为空）
                    p->nextarc = ptr2;
                    p = p->nextarc;
                }
                else
                    return ERROR;
            }
        }
    }
    Print(G);
    return OK;
}
//构造有向网
Status CreateDN(ALGraph& G)
{
    VertexType e;
    int num;
    cout << "该图共有多少个顶点、多少条弧?" << endl;
    cin >> G.vexnum >> G.arcnum;
    cout << "请输入各顶点:" << endl;
    for(int i = 0; i < G.vexnum; i++)
    {
        //注意存储结构
        cin >> G.vertices[i].data;
        //先将头节点的指针域设为空
        G.vertices[i].firstarc = NULL;
    }
    for(int i = 0; i < G.vexnum; i++)
    {
        //(强调引用)
        //注意ptr是节点的指针（是节点类型的一部分）而不是‘指向’节点的指针
        //所以接连各节点不想以前那样简单了
        ArcNode* &ptr = G.vertices[i].firstarc;
        cout << "请问以顶点" << G.vertices[i].data << "为起点的弧一共有多少条?" << endl;
        cin >> num;
        if(num > 0)
        {
            int Index;
            ArcNode* p = NULL;
            cout << "请将这些顶点及弧所带信息依次输入:" << endl;
            //先处理一个节点（为了方便后面的操作）
            ptr = new ArcNode;
            if(ptr)
            {
                cin >> e;
                //输入弧上的信息
                cin >> ptr->info;
                Index = LocateVex(G.vertices, G.vexnum, e);
                p = ptr;
                p->adjvex = Index;
                p->nextarc = NULL;
            }
            else
                return ERROR;
            for(int j = 1; j < num; j++)
            {
                ArcNode* ptr2 = new ArcNode;
                if(ptr2)
                {
                    //注意各变量的类型，不要搞混了
                    cin >> e;
                    //输入弧上的信息
                    cin >> ptr2->info;
                    Index = LocateVex(G.vertices, G.vexnum, e);
                    ptr2->adjvex = Index;
                    ptr2->nextarc = NULL;
                    //注意此处的连接节点与以前写的有点不同（ptr‘一直’为空）
                    p->nextarc = ptr2;
                    p = p->nextarc;
                }
                else
                    return ERROR;
            }
        }
    }
    Print(G);
    return OK;
}
//定位顶点在一维数组中的位置
int LocateVex(VNode vertices[], int vexnum, VertexType e)
{
    int i;
    for(i = 0; i < vexnum; i++)
    {
        if(vertices[i].data == e)
            break;
    }
    return i;
}
//打印图
void Print(const ALGraph& G)
{
    cout << "您所创建的图用邻接表存储结构展示如下:" << endl;
    for(int i = 0; i < G.vexnum; i++)
    {
        cout  << "[" << G.vertices[i].data << "]";
        ArcNode* ptr = G.vertices[i].firstarc;
        while(ptr)
        {
            //打印出下标（从零开始）
            cout  << "—>" << ptr->adjvex;
            ptr = ptr->nextarc;
        }
        cout << endl;
    }
}