图（无向）的邻接矩阵、邻接表存储结构

邻接矩阵存储结构（+深度遍历）

//邻接矩阵及深度遍历
#include<iostream>
#include<stdbool.h>
#define MaxInt 999//表示最大值 正无穷
#define MVNum 100//最大顶点数
#define OK 1

typedef char VerTexType;
typedef int ArcType;
using namespace std;

typedef struct
{
    VerTexType vexs[MVNum];//顶点表
    ArcType arcs[MVNum][MVNum];//邻接矩阵
    int vexnum, arcnum;//图的当前点数和边数
}AMGraph;

int CreateUDN(AMGraph &G)
{
    int i, j, k,w;
    cout << "输入总顶点数，总边数:" << endl;
    cin >> G.vexnum >> G.arcnum;//输入总顶点数，总边数
    for (i = 0; i < G.vexnum; ++i)
    {
        cout << "请输入各顶点的值：" << endl;
        cin >> G.vexs[i];//输入各顶点信息
    }
    for (i = 0; i < G.vexnum; ++i)
    {
        for (j = 0; j < G.vexnum; ++j)
        {
            G.arcs[i][j] = MaxInt;//都置为极大值MaxInt
        }
    }
    for (k = 0; k < G.vexnum; ++k)//构造邻接矩阵
    {
        cout << "请输入<vi,vj>的下标i，j和权值" << endl;
        cin >> i >> j >> w;//输入一条边依附的顶点和权值
        G.arcs[i][j] = w;//<v1,v2>边的权值置为w
        G.arcs[j][i] = G.arcs[i][j];//置<v1,v2>的对称边<v2,v1>的权值为w
    }
    return OK;
}

bool visited[MVNum];
//邻接矩阵 深度优先遍历
void DFS_AM(AMGraph G, int v)
{
    int w;
    cout << v;
    visited[v] = true;
    for (w = 0; w < G.vexnum; w++)
    {
        if ((G.arcs[v][w] != 0) && (!visited[w]))
        {
            DFS_AM(G, w);
        }
    }
}

int main()
{
    AMGraph G;
    CreateUDN(G);
    for (int i = 0; i < G.vexnum; i++)
    {
        for (int j = 0; j < G.vexnum; j++)
        {
            cout<< G.arcs[i][j]<<' ';
        }
        cout << endl;
    }

    cout << "深度优先遍历：" << endl;
    DFS_AM(G, 1);
    cout << endl;

    return 0;
}

邻接表存储结构

//邻接表
#include<iostream>
#define MVNum 100//最大顶点数
#define OK 1
using namespace std;

typedef struct ArcNode//边结点
{
    int adjvex;//该边所指向的顶点的位置
    struct ArcNode* nextarc;//指向下一条边的指针
    char info;//和边相关的信息
}ArcNode;

typedef struct VNode  //顶点信息
{
    char data;
    ArcNode* firstarc;//指向第一条依附该顶点的边的指针
}VNode,AdjList[MVNum]; //AdjList表示邻接表类型

typedef struct  //邻接表
{
    AdjList vertices;
    int vexnum, arcnum; //图的当前顶点数和边数
}ALGraph;

int CreateUDG(ALGraph& G)
{
    int i, j, k;
    cout << "输入总顶点数 总边数:" << endl;
    cin >> G.vexnum >> G.arcnum;//输入总顶点数 总边数
    cout << "输入各顶点值：" << endl;
    for (i = 0; i < G.vexnum; ++i)//输入各点，构造表头结点
    {
        cin >> G.vertices[i].data;//输入顶点值
        G.vertices[i].firstarc = NULL;//初始化表头结点的指针域为NULL
    }
    for (k = 0; k < G.vexnum; ++k)
    {
        cout << "请输入<vi,vj>的下标i，j" << endl;
        cin >> i >> j ;//输入一条边依附的顶点
        ArcNode* p1 = new ArcNode;
        p1->adjvex = j;
        p1->nextarc = G.vertices[i].firstarc;
        G.vertices[i].firstarc = p1;

        ArcNode* p2 = new ArcNode;
        p2->adjvex = i;
        p2->nextarc = G.vertices[j].firstarc;
        G.vertices[j].firstarc = p2;
    }
    return OK;
}

int main()
{
    ALGraph G;
    ArcNode* p;
    CreateUDG(G);

    cout << "依次输出各顶点邻接表： " << endl;

    ArcNode* temp = NULL;
    for (int i = 0; i <G.vexnum ; ++i)
    {
        temp = G.vertices[i].firstarc;
        while (temp)
        {
            cout << temp->adjvex << " ";
            temp = temp->nextarc;
        }
        cout << endl;

    }
    return 0;
}

邻接矩阵存储结构运行截图：

邻接表存储结构运行截图：