《数据结构》-图的邻接矩阵表示法(三)

最新推荐文章于 2022-08-09 00:14:22 发布
最新推荐文章于 2022-08-09 00:14:22 发布
阅读量6.6k 收藏 26
点赞数 8
分类专栏： 数据结构 文章标签： 图 数据结构 邻接矩阵 深度优先遍历 广度优先遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tyustli/article/details/119335674
版权

图的存储结构

图的逻辑结构是：多对多


图的存储方式

数组(邻接矩阵)表示法

定义

图没有顺序存储结构，但可以借助二维数组来表示元素间的关系

  • 建立一个顶点表(记录各个顶点信息)，和一个邻接矩阵(表示各个顶点之间的关系)

  • 设图 A = (V,E)，有 n 个顶点，则
    顶点表的为

i012…n-1
Vexs[i]V1V2V3…Vn
  • 图的邻接矩阵是一个二维数组 A.arcs[n][n] 定义为：A.arcs[i][j] = 1 存在从 i 顶点到 j 顶点的弧或者边，否则 A.arcs[i][j] = 0

无向图的邻接矩阵

如下无向图


无向图

则它的邻接矩阵为


无向图的邻接矩阵

在无向图的邻接矩阵中，它的特点：

  • 无向图的邻接矩阵是对称的
  • 顶点 i 的度 = 第 i 行/列 中 1 的个数
  • 完全图的邻接矩阵中，对角元素为 0 ，其余为 1

有向图的邻接矩阵

如下有向图


有向图

则它的邻接矩阵为


有向图的邻接矩阵

第 i 行含义：以节点 Vi 为尾的弧(即出度边)

第 i 列含义：以节点 Vi 为头的弧(即入度边)

在有向图的邻接矩阵中，它的特点：

  • 有向图的邻接矩阵可能是不对称的
  • 顶点的出度 = 第 i 行元素之和
  • 顶点的入度 = 第 i 列元素之和
  • 顶点的度 = 第 i 行元素之和 + 第 i 列元素之和

网(即有权图)的邻接矩阵表示法

定义为：A.arcs[i][j] = Wij 存在从 i 顶点到 j 顶点的弧或者边的权，否则 A.arcs[i][j] = 无穷大

如下网


有向网

则它的邻接矩阵为


有向网的邻接矩阵

邻接矩阵的优缺点

优点：

  • 直观、简单、好理解
  • 方便检查任意一对顶点间是否存在边
  • 方便找任一顶点的所有邻接点(右边直接相连的顶点)
  • 方便计算任一顶点的度(从该点发出的边数为出度，指向该点的边数为入度)
    • 无向图：对应行(或列)非0元素的个数
    • 有向图：对应行非0元素的个数是出度；对应列非0元素的个数是入度

缺点：

  • 不便于增加和删除顶点
  • 浪费空间-存稀疏图(点很多而边很少)有大量无效元素
    • 对稠密图(特别是完全图)还是很合算的
  • 浪费时间-统计稀疏图中一共有多少条边

邻接矩阵的存储表示

#define INFINITY INT_MAX  // 用整型最大值代替∞
#define MAX_VERTEX_NUM 26 // 最大顶点个数
#define MAX_NAME 3        // 顶点字符串的最大长度+1
#define MAX_INFO 20       // 相关信息字符串的最大长度+1

enum GraphKind
{
    DG,
    DN,
    UDG,
    UDN
}; // {有向图,有向网,无向图,无向网}

typedef int VRType;
typedef char InfoType;
typedef char VertexType[MAX_NAME]; // 顶点类型

typedef struct
{
    VRType adj;                                       // 顶点关系类型。对无权图，用1(是)或0(否)表示相邻否；对带权图，则为权值
    InfoType *info;                                   // 该弧相关信息的指针(可无)
} ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 二维数组

struct MGraph
{
    VertexType vexs[MAX_VERTEX_NUM]; // 顶点向量
    AdjMatrix arcs;                  // 邻接矩阵
    int vexnum, arcnum;              // 图的当前顶点数和弧数
    enum GraphKind kind;             // 图的种类标志
};

邻接矩阵的代码实现

图的邻接矩阵的代码实现中主要包括

  • 从文件中创建无向图
  • 从文件中创建无向网
  • 无向网、无向图，有向网，有向图的创建
  • 深度优先遍历
  • 广度优先遍历
main.c
/*
 * Change Logs:
 * Date           Author       Notes
 * 2021-08.03     tyustli      first version
 */

#include "graph.h"

void visit(VertexType i)
{
    printf("%s ", i);
}

int main(int argc, char *argv[])
{
    printf("this is graph\r\n");

    struct MGraph g;
    CreateFUDG(&g);
    Display(g);
    printf("深度优先遍历\r\n");
    DFSTraverse(g, visit);

    printf("广度优先遍历\r\n");
    BFSTraverse(g, visit);

    return 1;
}

/*
 * 编译：make
 * 运行：./obj
 * graph.txt 文件内容
 8
14
a
b
c
d
e
f
g
h
a b
a c
a e
a f
a g
a h
b d
b e
b h
c g
c h
d h
e f
f g
运行结果：
this is graph
请输入数据文件名(graph.txt或net.txt)：graph.txt
8个顶点14条边或弧的无向图。顶点依次是: a b c d e f g h
G.arcs.adj:
          0          1          1          0          1          1          1          1
          1          0          0          1          1          0          0          1
          1          0          0          0          0          0          1          1
          0          1          0          0          0          0          0          1
          1          1          0          0          0          1          0          0
          1          0          0          0          1          0          1          0
          1          0          1          0          0          1          0          0
          1          1          1          1          0          0          0          0
G.arcs.info:
顶点1(弧尾) 顶点2(弧头) 该边或弧的信息：
深度优先遍历
a b d h c g f e
广度优先遍历
a b c e f g h d
*/
makefile

文件很少

objects  = main.o graph.o
obj: $(objects)
	cc -o obj $(objects) -lm

main.o : graph.h
graph.o : graph.h

.PHONY : clean
clean :
	-rm obj $(objects)
graph.h

图/网的基本操作 API 的声明

/*
 * Change Logs:
 * Date           Author       Notes
 * 2021-08.03     tyustli      first version
 */

#include <string.h>
#include <ctype.h>
#include <malloc.h> // malloc()等
#include <limits.h> // INT_MAX等
#include <stdio.h>  // EOF(=^Z或F6),NULL
#include <stdlib.h> // atoi()

// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;  // Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE

#define INFINITY INT_MAX  // 用整型最大值代替∞
#define MAX_VERTEX_NUM 26 // 最大顶点个数
#define MAX_NAME 3        // 顶点字符串的最大长度+1
#define MAX_INFO 20       // 相关信息字符串的最大长度+1

enum GraphKind
{
    DG,
    DN,
    UDG,
    UDN
}; // {有向图,有向网,无向图,无向网}

typedef int VRType;
typedef char InfoType;
typedef char VertexType[MAX_NAME]; // 顶点类型

typedef struct
{
    VRType adj;                                       // 顶点关系类型。对无权图，用1(是)或0(否)表示相邻否；对带权图，则为权值
    InfoType *info;                                   // 该弧相关信息的指针(可无)
} ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 二维数组

struct MGraph
{
    VertexType vexs[MAX_VERTEX_NUM]; // 顶点向量
    AdjMatrix arcs;                  // 邻接矩阵
    int vexnum, arcnum;              // 图的当前顶点数和弧数
    enum GraphKind kind;             // 图的种类标志
};

void CreateFUDG(struct MGraph *G);
void CreateFUDN(struct MGraph *G);
void CreateDG(struct MGraph *G);
void CreateDN(struct MGraph *G);
void CreateUDG(struct MGraph *G);
void CreateUDN(struct MGraph *G);
void CreateGraph(struct MGraph *G);
void DestroyGraph(struct MGraph *G);
VertexType *GetVex(struct MGraph G, int v);
Status PutVex(struct MGraph *G, VertexType v, VertexType value);
int FirstAdjVex(struct MGraph G, VertexType v);
int NextAdjVex(struct MGraph G, VertexType v, VertexType w);
void InsertVex(struct MGraph *G, VertexType v);
Status DeleteVex(struct MGraph *G, VertexType v);
Status InsertArc(struct MGraph *G, VertexType v, VertexType w);
Status DeleteArc(struct MGraph *G, VertexType v, VertexType w);
void DFSTraverse(struct MGraph G, void (*Visit)(VertexType));
void BFSTraverse(struct MGraph G, void (*Visit)(VertexType));
void Display(struct MGraph G);
/************************ end of file **************************/
graph.c

图/网的邻接矩阵的代码实现

/*
 * Change Logs:
 * Date           Author       Notes
 * 2021-08.03     tyustli      first version
 */

#include "graph.h"

// 图的数组(邻接矩阵)存储(存储结构由graph.h定义)的基本操作

// 初始条件：图 G 存在，u 和 G 中顶点有相同特征
// 操作结果：若 G 中存在顶点u，则返回该顶点在图中位置；否则返回 -1
static int LocateVex(struct MGraph G, VertexType u)
{
    int i;
    for (i = 0; i < G.vexnum; ++i)
    {
        if (strcmp(u, G.vexs[i]) == 0)
            return i;
    }
    return -1;
}

// 采用数组(邻接矩阵)表示法，由文件构造没有相关信息的无向图 G
void CreateFUDG(struct MGraph *G)
{
    int i, j, k;
    char filename[13];
    VertexType va, vb;
    FILE *graphlist;
    printf("请输入数据文件名(graph.txt或net.txt)：");
    scanf("%s", filename);
    graphlist = fopen(filename, "r"); // 打开数据文件，并以graphlist表示
    fscanf(graphlist, "%d", &G->vexnum);
    fscanf(graphlist, "%d", &G->arcnum);
    for (i = 0; i < G->vexnum; ++i) // 构造顶点向量
        fscanf(graphlist, "%s", G->vexs[i]);
    for (i = 0; i < G->vexnum; ++i) // 初始化邻接矩阵
    {
        for (j = 0; j < G->vexnum; ++j)
        {
            G->arcs[i][j].adj = 0;     // 图
            G->arcs[i][j].info = NULL; // 没有相关信息
        }
    }
    for (k = 0; k < G->arcnum; ++k)
    {
        fscanf(graphlist, "%s%s", va, vb);
        i = LocateVex((*G), va);
        j = LocateVex((*G), vb);
        G->arcs[i][j].adj = G->arcs[j][i].adj = 1; // 无向图
    }
    fclose(graphlist); // 关闭数据文件
    G->kind = UDG;
}

// 采用数组(邻接矩阵)表示法，由文件构造没有相关信息的无向网 G
void CreateFUDN(struct MGraph *G)
{
    int i, j, k, w;
    char filename[13];
    VertexType va, vb;
    FILE *graphlist;
    printf("请输入数据文件名：");
    scanf("%s", filename);
    graphlist = fopen(filename, "r"); // 打开数据文件，并以graphlist表示
    fscanf(graphlist, "%d", &G->vexnum);
    fscanf(graphlist, "%d", &G->arcnum);
    for (i = 0; i < G->vexnum; ++i) // 构造顶点向量
        fscanf(graphlist, "%s", G->vexs[i]);
    for (i = 0; i < G->vexnum; ++i) // 初始化邻接矩阵
    {
        for (j = 0; j < G->vexnum; ++j)
        {
            G->arcs[i][j].adj = INFINITY; // 网
            G->arcs[i][j].info = NULL;    // 没有相关信息
        }
    }
    for (k = 0; k < G->arcnum; ++k)
    {
        fscanf(graphlist, "%s%s%d", va, vb, &w);
        i = LocateVex(*G, va);
        j = LocateVex(*G, vb);
        G->arcs[i][j].adj = G->arcs[j][i].adj = w; // 无向网
    }
    fclose(graphlist); // 关闭数据文件
    G->kind = UDN;
}

// 采用数组(邻接矩阵)表示法，构造有向图G
void CreateDG(struct MGraph *G)
{
    int i, j, k, l, IncInfo;
    char s[MAX_INFO];
    VertexType va, vb;
    printf("请输入有向图G的顶点数,弧数,弧是否含其它信息(是:1,否:0): ");
    scanf("%d,%d,%d", &G->vexnum, &G->arcnum, &IncInfo);
    printf("请输入%d个顶点的值(<%d个字符):\n", G->vexnum, MAX_NAME);
    for (i = 0; i < G->vexnum; ++i) // 构造顶点向量
        scanf("%s", G->vexs[i]);
    for (i = 0; i < G->vexnum; ++i) // 初始化邻接矩阵
    {
        for (j = 0; j < G->vexnum; ++j)
        {
            G->arcs[i][j].adj = 0; // 图
            G->arcs[i][j].info = NULL;
        }
    }
    printf("请输入%d条弧的弧尾 弧头(以空格作为间隔): \n", G->arcnum);
    for (k = 0; k < G->arcnum; ++k)
    {
        scanf("%s%s%*c", va, vb); // %*c吃掉回车符
        i = LocateVex(*G, va);
        j = LocateVex(*G, vb);
        G->arcs[i][j].adj = 1; // 有向图
        if (IncInfo)
        {
            printf("请输入该弧的相关信息(<%d个字符): ", MAX_INFO);
            scanf("%s", s);
            l = strlen(s);
            if (l)
            {
                G->arcs[i][j].info = (char *)malloc((l + 1) * sizeof(char)); // 有向
                strcpy(G->arcs[i][j].info, s);
            }
        }
    }
    G->kind = DG;
}

// 采用数组(邻接矩阵)表示法，构造有向网G
void CreateDN(struct MGraph *G)
{
    int i, j, k, w, IncInfo;
    char s[MAX_INFO];
    VertexType va, vb;
    printf("请输入有向网G的顶点数,弧数,弧是否含其它信息(是:1,否:0): ");
    scanf("%d,%d,%d", &G->vexnum, &G->arcnum, &IncInfo);
    printf("请输入%d个顶点的值(<%d个字符):\n", G->vexnum, MAX_NAME);
    for (i = 0; i < G->vexnum; ++i) // 构造顶点向量
        scanf("%s", G->vexs[i]);
    for (i = 0; i < G->vexnum; ++i) // 初始化邻接矩阵
    {
        for (j = 0; j < G->vexnum; ++j)
        {
            G->arcs[i][j].adj = INFINITY; // 网
            G->arcs[i][j].info = NULL;
        }
    }
    printf("请输入%d条弧的弧尾 弧头 权值(以空格作为间隔): \n", G->arcnum);
    for (k = 0; k < G->arcnum; ++k)
    {
        scanf("%s%s%d%*c", va, vb, &w); // %*c吃掉回车符
        i = LocateVex(*G, va);
        j = LocateVex(*G, vb);
        G->arcs[i][j].adj = w; // 有向网
        if (IncInfo)
        {
            printf("请输入该弧的相关信息(<%d个字符): ", MAX_INFO);
            scanf("%s", s);
            w = strlen(s);
            if (w)
            {
                G->arcs[i][j].info = (char *)malloc((w + 1) * sizeof(char)); // 有向
                strcpy(G->arcs[i][j].info, s);
            }
        }
    }
    G->kind = DN;
}

// 采用数组(邻接矩阵)表示法，构造无向图G
void CreateUDG(struct MGraph *G)
{
    int i, j, k, l, IncInfo;
    char s[MAX_INFO];
    VertexType va, vb;
    printf("请输入无向图G的顶点数,边数,边是否含其它信息(是:1,否:0): ");
    scanf("%d,%d,%d", &G->vexnum, &G->arcnum, &IncInfo);
    printf("请输入 %d 个顶点的值(<%d个字符):\n", G->vexnum, MAX_NAME);
    for (i = 0; i < G->vexnum; ++i) // 构造顶点向量
        scanf("%s", G->vexs[i]);
    for (i = 0; i < G->vexnum; ++i) // 初始化邻接矩阵
    {
        for (j = 0; j < G->vexnum; ++j)
        {
            G->arcs[i][j].adj = 0; // 图
            G->arcs[i][j].info = NULL;
        }
    }
    printf("请输入 %d 条边的顶点1 顶点2(以空格作为间隔): \n", G->arcnum);
    for (k = 0; k < G->arcnum; ++k)
    {
        scanf("%s%s%*c", va, vb); // %*c吃掉回车符
        i = LocateVex(*G, va);
        j = LocateVex(*G, vb);
        G->arcs[i][j].adj = G->arcs[j][i].adj = 1; // 无向图
        if (IncInfo)
        {
            printf("请输入该边的相关信息(<%d个字符): ", MAX_INFO);
            scanf("%s", s);
            l = strlen(s);
            if (l)
            {
                G->arcs[i][j].info = G->arcs[j][i].info = (char *)malloc((l + 1) * sizeof(char));
                // 无向，两个指针指向同一个信息
                strcpy(G->arcs[i][j].info, s);
            }
        }
    }
    G->kind = UDG;
}

// 采用数组(邻接矩阵)表示法，构造无向网G。算法7.2
void CreateUDN(struct MGraph *G)
{
    int i, j, k, w, IncInfo;
    char s[MAX_INFO];
    VertexType va, vb;
    printf("请输入无向网G的顶点数,边数,边是否含其它信息(是:1,否:0): ");
    scanf("%d,%d,%d", &G->vexnum, &G->arcnum, &IncInfo);
    printf("请输入%d个顶点的值(<%d个字符):\n", G->vexnum, MAX_NAME);
    for (i = 0; i < G->vexnum; ++i) // 构造顶点向量
        scanf("%s", G->vexs[i]);
    for (i = 0; i < G->vexnum; ++i) // 初始化邻接矩阵
    {
        for (j = 0; j < G->vexnum; ++j)
        {
            G->arcs[i][j].adj = INFINITY; // 网
            G->arcs[i][j].info = NULL;
        }
    }
    printf("请输入%d条边的顶点1 顶点2 权值(以空格作为间隔): \n", G->arcnum);
    for (k = 0; k < G->arcnum; ++k)
    {
        scanf("%s%s%d%*c", va, vb, &w); // %*c吃掉回车符
        i = LocateVex(*G, va);
        j = LocateVex(*G, vb);
        G->arcs[i][j].adj = G->arcs[j][i].adj = w; // 无向
        if (IncInfo)
        {
            printf("请输入该边的相关信息(<%d个字符): ", MAX_INFO);
            scanf("%s", s);
            w = strlen(s);
            if (w)
            {
                G->arcs[i][j].info = G->arcs[j][i].info = (char *)malloc((w + 1) * sizeof(char));
                // 无向，两个指针指向同一个信息
                strcpy(G->arcs[i][j].info, s);
            }
        }
    }
    G->kind = UDN;
}

// 采用数组(邻接矩阵)表示法，构造图G
void CreateGraph(struct MGraph *G)
{
    printf("请输入图G的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
    scanf("%d", (int *)&G->kind);
    switch (G->kind)
    {
    case DG:
        CreateDG(G); // 构造有向图
        break;
    case DN:
        CreateDN(G); // 构造有向网
        break;
    case UDG:
        CreateUDG(G); // 构造无向图
        break;
    case UDN:
        CreateUDN(G); // 构造无向网
    }
}

// 初始条件：图G存在。
// 操作结果：销毁图G
void DestroyGraph(struct MGraph *G)
{
    int i, j, k = 0;
    if (G->kind % 2)                // 网
        k = INFINITY;               // k为两顶点之间无边或弧时邻接矩阵元素的值
    for (i = 0; i < G->vexnum; i++) // 释放弧或边的相关信息(如果有的话)
    {
        if (G->kind < 2) // 有向
        {
            for (j = 0; j < G->vexnum; j++)
            {
                if (G->arcs[i][j].adj != k) // 有弧
                    if (G->arcs[i][j].info) // 有相关信息
                    {
                        free(G->arcs[i][j].info);
                        G->arcs[i][j].info = NULL;
                    }
            }
        }
        else // 无向
        {
            for (j = i + 1; j < G->vexnum; j++) // 只查上三角
            {
                if (G->arcs[i][j].adj != k) // 有边
                    if (G->arcs[i][j].info) // 有相关信息
                    {
                        free(G->arcs[i][j].info);
                        G->arcs[i][j].info = G->arcs[j][i].info = NULL;
                    }
            }
        }
    }
    G->vexnum = 0; // 顶点数为0
    G->arcnum = 0; // 边数为0
}

// 初始条件：图G存在，v是G中某个顶点的序号。
// 操作结果：返回v的值
VertexType *GetVex(struct MGraph G, int v)
{
    if (v >= G.vexnum || v < 0)
        exit(ERROR);
    return G.vexs[v];
}

// 初始条件：图G存在，v是G中某个顶点。
// 操作结果：对v赋新值value
Status PutVex(struct MGraph *G, VertexType v, VertexType value)
{
    int k;
    k = LocateVex(*G, v); // k为顶点v在图G中的序号
    if (k < 0)
        return ERROR;
    strcpy(G->vexs[k], value);
    return OK;
}

// 初始条件：图G存在，v是G中某个顶点
// 操作结果：返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点，则返回-1
int FirstAdjVex(struct MGraph G, VertexType v)
{
    int i, j = 0, k;
    k = LocateVex(G, v); // k为顶点v在图G中的序号
    if (G.kind % 2)      // 网
        j = INFINITY;
    for (i = 0; i < G.vexnum; i++)
    {
        if (G.arcs[k][i].adj != j)
            return i;
    }
    return -1;
}

// 初始条件：图G存在，v是G中某个顶点，w是v的邻接顶点
// 操作结果：返回v的(相对于w的)下一个邻接顶点的序号，若w是v的最后一个邻接顶点，则返回-1
int NextAdjVex(struct MGraph G, VertexType v, VertexType w)
{
    int i, j = 0, k1, k2;
    k1 = LocateVex(G, v); // k1为顶点v在图G中的序号
    k2 = LocateVex(G, w); // k2为顶点w在图G中的序号
    if (G.kind % 2)       // 网
        j = INFINITY;
    for (i = k2 + 1; i < G.vexnum; i++)
        if (G.arcs[k1][i].adj != j)
            return i;
    return -1;
}

// 初始条件：图G存在，v和图G中顶点有相同特征
// 操作结果：在图G中增添新顶点v(不增添与顶点相关的弧，留待InsertArc()去做)
void InsertVex(struct MGraph *G, VertexType v)
{
    int i, j = 0;
    if (G->kind % 2) // 网
        j = INFINITY;
    strcpy(G->vexs[G->vexnum], v); // 构造新顶点向量
    for (i = 0; i <= G->vexnum; i++)
    {
        G->arcs[G->vexnum][i].adj = G->arcs[i][G->vexnum].adj = j;
        // 初始化新增行、新增列邻接矩阵的值(无边或弧)
        G->arcs[G->vexnum][i].info = G->arcs[i][G->vexnum].info = NULL; // 初始化相关信息指针
    }
    G->vexnum++; // 图G的顶点数加1
}

// 初始条件：图G存在，v是G中某个顶点。
// 操作结果：删除G中顶点v及其相关的弧
Status DeleteVex(struct MGraph *G, VertexType v)
{
    int i, j, k;
    VRType m = 0;
    if (G->kind % 2) // 网
        m = INFINITY;
    k = LocateVex(*G, v); // k为待删除顶点v的序号
    if (k < 0)            // v不是图G的顶点
        return ERROR;
    for (j = 0; j < G->vexnum; j++)
    {
        if (G->arcs[j][k].adj != m) // 有入弧或边
        {
            if (G->arcs[j][k].info)       // 有相关信息
                free(G->arcs[j][k].info); // 释放相关信息
            G->arcnum--;                  // 修改弧数
        }
    }
    if (G->kind < 2) // 有向
    {
        for (j = 0; j < G->vexnum; j++)
            if (G->arcs[k][j].adj != m) // 有出弧
            {
                if (G->arcs[k][j].info)       // 有相关信息
                    free(G->arcs[k][j].info); // 释放相关信息
                G->arcnum--;                  // 修改弧数
            }
    }
    for (j = k + 1; j < G->vexnum; j++) // 序号k后面的顶点向量依次前移
        strcpy(G->vexs[j - 1], G->vexs[j]);
    for (i = 0; i < G->vexnum; i++)
        for (j = k + 1; j < G->vexnum; j++)
            G->arcs[i][j - 1] = G->arcs[i][j]; // 移动待删除顶点之右的矩阵元素
    for (i = 0; i < G->vexnum; i++)
        for (j = k + 1; j < G->vexnum; j++)
            G->arcs[j - 1][i] = G->arcs[j][i]; // 移动待删除顶点之下的矩阵元素
    G->vexnum--;                               // 更新图的顶点数
    return OK;
}

// 初始条件：图G存在，v和w是G中两个顶点
// 操作结果：在G中增添弧<v,w>，若G是无向的，则还增添对称弧<w,v>
Status InsertArc(struct MGraph *G, VertexType v, VertexType w)
{
    int i, l, v1, w1;
    char s[MAX_INFO];
    v1 = LocateVex(*G, v); // 尾
    w1 = LocateVex(*G, w); // 头
    if (v1 < 0 || w1 < 0)
        return ERROR;
    G->arcnum++;     // 弧或边数加1
    if (G->kind % 2) // 网
    {
        printf("请输入此弧或边的权值: ");
        scanf("%d", &G->arcs[v1][w1].adj);
    }
    else // 图
        G->arcs[v1][w1].adj = 1;
    printf("是否有该弧或边的相关信息(0:无 1:有): ");
    scanf("%d%*c", &i);
    if (i)
    {
        printf("请输入该弧或边的相关信息(<%d个字符)：", MAX_INFO);
        scanf("%s", s);
        l = strlen(s);
        if (l)
        {
            G->arcs[v1][w1].info = (char *)malloc((l + 1) * sizeof(char));
            strcpy(G->arcs[v1][w1].info, s);
        }
    }
    if (G->kind > 1) // 无向
    {
        G->arcs[w1][v1].adj = G->arcs[v1][w1].adj;
        G->arcs[w1][v1].info = G->arcs[v1][w1].info; // 指向同一个相关信息
    }

    return OK;
}

// 初始条件：图G存在，v和w是G中两个顶点
// 操作结果：在G中删除弧<v,w>，若G是无向的，则还删除对称弧<w,v>
Status DeleteArc(struct MGraph *G, VertexType v, VertexType w)
{
    int v1, w1, j = 0;
    if (G->kind % 2) // 网
        j = INFINITY;
    v1 = LocateVex(*G, v); // 尾
    w1 = LocateVex(*G, w); // 头
    if (v1 < 0 || w1 < 0)  // v1、w1的值不合法
        return ERROR;
    G->arcs[v1][w1].adj = j;
    if (G->arcs[v1][w1].info) // 有其它信息
    {
        free(G->arcs[v1][w1].info);
        G->arcs[v1][w1].info = NULL;
    }
    if (G->kind >= 2) // 无向，删除对称弧<w,v>
    {
        G->arcs[w1][v1].adj = j;
        G->arcs[w1][v1].info = NULL;
    }
    G->arcnum--; // 弧数-1

    return OK;
}

Boolean visited[MAX_VERTEX_NUM]; // 访问标志数组(全局量)
void (*VisitFunc)(VertexType);   // 函数变量
// 从第v个顶点出发递归地深度优先遍历图G。算法7.5
static void DFS(struct MGraph G, int v)
{
    int w;
    visited[v] = TRUE;    // 设置访问标志为TRUE(已访问)
    VisitFunc(G.vexs[v]); // 访问第v个顶点
    for (w = FirstAdjVex(G, G.vexs[v]); w >= 0; w = NextAdjVex(G, G.vexs[v], G.vexs[w]))
        if (!visited[w])
            DFS(G, w); // 对v的尚未访问的序号为w的邻接顶点递归调用DFS
}

// 初始条件：图G存在，Visit是顶点的应用函数。算法7.4
// 操作结果：从第1个顶点起，深度优先遍历图G，并对每个顶点调用函数Visit一次且仅一次
void DFSTraverse(struct MGraph G, void (*Visit)(VertexType))
{
    int v;
    VisitFunc = Visit; // 使用全局变量VisitFunc，使DFS不必设函数指针参数
    for (v = 0; v < G.vexnum; v++)
        visited[v] = FALSE; // 访问标志数组初始化(未被访问)
    for (v = 0; v < G.vexnum; v++)
        if (!visited[v])
            DFS(G, v); // 对尚未访问的顶点v调用DFS
    printf("\n");
}

typedef VRType QElemType; // 队列元素类型

#if 1
typedef struct QNode
{
    QElemType data;     /* 数据域 */
    struct QNode *next; /* 指针域 */
} QNode, *QueuePtr;
typedef struct LinkQueue
{
    QueuePtr front; // 队头指针
    QueuePtr rear;  // 队尾指针
} LinkQueue;
void InitQueue(LinkQueue *Q);
void DestroyQueue(LinkQueue *Q);
void ClearQueue(LinkQueue *Q);
Status QueueEmpty(LinkQueue Q);
int QueueLength(LinkQueue Q);
Status GetHead(LinkQueue Q, QElemType *e);
void EnQueue(LinkQueue *Q, QElemType e);
Status DeQueue(LinkQueue *Q, QElemType *e);
void QueueTraverse(LinkQueue Q, void (*vi)(QElemType));
void print(QElemType i);
void InitQueue(LinkQueue *Q)
{                                                         // 构造一个空队列 Q
    Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode)); /* 单链表的头结点 */

    if (Q->front == NULL)
        exit(-1);
    Q->front->next = NULL;
}
void DestroyQueue(LinkQueue *Q)
{
    while (Q->front)
    {
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
}
void ClearQueue(LinkQueue *Q)
{
    QueuePtr p, q;
    Q->rear = Q->front;
    p = Q->front->next;
    Q->front->next = NULL;
    while (p)
    {
        q = p;
        p = p->next;
        free(q);
    }
}
Status QueueEmpty(LinkQueue Q)
{
    if (Q.front->next == NULL)
        return TRUE;
    else
        return FALSE;
}
int QueueLength(LinkQueue Q)
{
    int i = 0;
    QueuePtr p;
    p = Q.front;
    while (Q.rear != p)
    {
        i++;
        p = p->next;
    }
    return i;
}
Status GetHead(LinkQueue Q, QElemType *e)
{
    QueuePtr p;
    if (Q.front == Q.rear)
        return ERROR;
    p = Q.front->next;
    *e = p->data;

    return OK;
}
void EnQueue(LinkQueue *Q, QElemType e)
{
    QueuePtr p;
    if (!(p = (QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败
        exit(-1);
    p->data = e;
    p->next = NULL;    /* 新结点的 next 为空 */
    Q->rear->next = p; /* 上一次的尾指针指向新的结点 */
    Q->rear = p;       /* 新的尾指针 */
}
Status DeQueue(LinkQueue *Q, QElemType *e)
{
    QueuePtr p;
    if (Q->front == Q->rear)
        return ERROR;
    p = Q->front->next;
    *e = p->data;
    Q->front->next = p->next;
    if (Q->rear == p)
        Q->rear = Q->front;
    free(p);

    return OK;
}
void QueueTraverse(LinkQueue Q, void (*vi)(QElemType))
{
    QueuePtr p;
    p = Q.front->next;
    while (p)
    {
        vi(p->data);
        p = p->next;
    }
    printf("\n");
}

void print(QElemType i)
{
    // printf("%s ", i);
}
#endif

void BFSTraverse(struct MGraph G, void (*Visit)(VertexType))
{ // 初始条件：图G存在，Visit是顶点的应用函数。算法7.6
    // 操作结果：从第1个顶点起，按广度优先非递归遍历图G,并对每个顶点调用函数Visit一次且仅一次
    int v, u, w;
    LinkQueue Q; // 使用辅助队列Q和访问标志数组visited
    for (v = 0; v < G.vexnum; v++)
        visited[v] = FALSE; // 置初值
    InitQueue(&Q);          // 置空的辅助队列Q
    for (v = 0; v < G.vexnum; v++)
        if (!visited[v]) // v尚未访问
        {
            visited[v] = TRUE; // 设置访问标志为TRUE(已访问)
            Visit(G.vexs[v]);
            EnQueue(&Q, v);        // v入队列
            while (!QueueEmpty(Q)) // 队列不空
            {
                DeQueue(&Q, &u); // 队头元素出队并置为u
                for (w = FirstAdjVex(G, G.vexs[u]); w >= 0; w = NextAdjVex(G, G.vexs[u], G.vexs[w]))
                    if (!visited[w]) // w为u的尚未访问的邻接顶点的序号
                    {
                        visited[w] = TRUE;
                        Visit(G.vexs[w]);
                        EnQueue(&Q, w);
                    }
            }
        }
    printf("\n");
}

void Display(struct MGraph G)
{ // 输出邻接矩阵存储表示的图G
    int i, j;
    char s[20];
    switch (G.kind)
    {
    case DG:
        strcpy(s, "有向图");
        break;
    case DN:
        strcpy(s, "有向网");
        break;
    case UDG:
        strcpy(s, "无向图");
        break;
    case UDN:
        strcpy(s, "无向网");
    }
    printf("%d个顶点%d条边或弧的%s。顶点依次是: ", G.vexnum, G.arcnum, s);
    for (i = 0; i < G.vexnum; ++i) // 输出G.vexs
        printf("%s ", G.vexs[i]);
    printf("\nG.arcs.adj:\n"); // 输出G.arcs.adj
    for (i = 0; i < G.vexnum; i++)
    {
        for (j = 0; j < G.vexnum; j++)
            printf("%11d", G.arcs[i][j].adj);
        printf("\n");
    }
    printf("G.arcs.info:\n"); // 输出G.arcs.info
    printf("顶点1(弧尾) 顶点2(弧头) 该边或弧的信息：\n");
    for (i = 0; i < G.vexnum; i++)
        if (G.kind < 2) // 有向
        {
            for (j = 0; j < G.vexnum; j++)
                if (G.arcs[i][j].info)
                    printf("%5s %11s     %s\n", G.vexs[i], G.vexs[j], G.arcs[i][j].info);
        }
        else // 无向,输出上三角
        {
            for (j = i + 1; j < G.vexnum; j++)
                if (G.arcs[i][j].info)
                    printf("%5s %11s     %s\n", G.vexs[i], G.vexs[j], G.arcs[i][j].info);
        }
}
tyustli
关注
专栏目录
图的邻接矩阵表示（完整版）
shijiemoxing的专栏
08-06 2021
/* *图的邻接矩阵表示 */ #include//EOF(=^Z或F6),NULL #include #include//INT_MAX等 #include #define MAX_NAME 5//顶点字符串的最大长度+1 #define MAX_IN
数据结构 图 邻接矩阵表示法
oowadanoko的博客
01-29 1825
图 邻接矩阵表示法 基本结构： enum GraphKind { DG, DN, UDG, UDN }; template<typename VRType, typename InfoType> struct ArcCell { VRType adj; InfoType* info; }; template<typename VRType, typename InfoType> using AdjMatrix = ArcCell<VRType, InfoType>
20.数据结构 图的存储结构
打工人的博客
12-02 544
图的逻辑结构：多对多 图没有顺序存储结构，但可以借助二维数组来表示元素间的关系 数组表示法（邻接矩阵） 链式存储结构：多重链表->邻接表/邻接多重表/十字链表 重点介绍： 邻接矩阵（数组）表示法 邻接表（链式）表示法 1.邻接矩阵 1.数组（邻接矩阵）表示法 无向图的邻接矩阵表示法 有向图的邻接矩阵表示法 ...
邻接矩阵表示法
qq_63306482的博客
05-01 1639
输入 输入的第一行是两个整数，分别是图的总顶点数n和总边数e 第二行是n个空格分开的字符串，是顶点的名字，依次对应编号0~n-1。 随后有e行，每行两个空格分开的顶点名字，表示一条边的两个顶点。 具体见样例。 输出 首先输出n行，每行是第i个顶点的邻接顶点。 再输出该图的邻接矩阵。 具体见样例。 样例输入Copy 8 9 v1 v2 v3 v4 v5 v6 v7 v8 v1 v2 v1 v3 v2 v4 v2 v5 v3 v6 v3 v7 v4 v8 v5 v8 v6 v7 样例.
图(2)—— 邻接矩阵表示法
专注于此刻
07-08 284
图的存储结构 图的存储结构比较复杂，其复杂性主要表现在： ◆任意顶点之间可能存在联系，无法以数据元素在存储区中的物理位置来表示元素之间的关系。 ◆图中顶点的度不一样，有的可能相差很大，若按度数最大的顶点设计结构，则会浪费很多存储单元，反之按每个顶点自己的度设计不同的结构，又会影响操作。 图的常用的存储结构有：邻接矩阵、邻接链表、十字链表、邻接多重表和边表，其中邻接...
图的邻接矩阵表示法
小牛的博客
09-08 493
图的邻接矩阵表示法 #include <cstdio> #include <string> #include <iostream> #include <algorithm> #define MaxVertexNum 1010 #define INF (1<<31)-1 using namespace std; //图的邻接矩阵表示法 ...
图的三种存储结构：邻接矩阵表示法+链表法+十字链表法
qq_63806300的博客
08-09 3709
图的三种存储结构：邻接矩阵表示法+链表法+十字链表法 C语言
数据结构-图的邻接矩阵表示法
最新发布
12-13
数据结构-图的邻接矩阵表示法
数据结构--图的邻接矩阵表示法
07-17
图的邻接矩阵表示法 深度优先搜索遍历 折半查找 数组模式
数据结构-3期（KC002） 无向图的邻接矩阵建立.docx
07-14
在邻接矩阵表示法中，我们使用一个二维数组来存储图的信息。这个数组的大小通常为n×n，其中n是图中顶点的数量。数组的每个元素表示对应顶点之间是否存在边。对于无向图，如果顶点i和顶点j之间存在边，则邻接矩阵的...
无向图的邻接矩阵表示
10-15
无向图的邻接矩阵表示
数据结构C语言--邻接矩阵表示有向网
z956206121的博客
11-28 3723
/**   * C: 邻接矩阵表示的"有向网"   *   * @author zk   * @date 2016/11/28   */ #include #include #include #include #define MaxInt 32767  //表示
图--邻接矩阵法
daa20的专栏
04-13 524
//MGraph.h #ifndef _MGRAPH_H_ #define _MGRAPH_H_ typedef void MGraph; typedef void MVertex; typedef void (MGraph_Printf)(MVertex*); MGraph* MGraph_Create(MVertex** v,int n); void MGraph_Destroy(MG
图的邻接矩阵表示及其基本操作
热门推荐
hellolde的博客
08-21 1万+
图的邻接矩阵表示及其基本操作 文章目录图的邻接矩阵表示及其基本操作1.邻接矩阵 1.邻接矩阵 表示图的一种简单方式是使用二维数组，称为邻接矩阵表示法。图中的每条边(v, w)，设置A[v][w]=1；若不存在边(v, w)，则A[v][w] = 0；如果边上带权值，那么可以设置A[v][w]等于该权值，同时使用一个很大或者很小的权值来表示不存在的边。如图，展示了无向图、有向图、有向网和它们的邻接矩阵。 邻接矩阵是一种顺序结构，从邻接矩阵的行数或者列数可知图的顶点数。无向图的邻接矩阵总是对称的，但有向图的邻
图的表示法---邻接矩阵
weixin_43213382的博客
08-15 342
构造一个具有n个顶点和e条边的图的时间复杂度是O(n^2+e*n)， 其中对邻接矩阵的初始化耗费了O(n^2)的时间 #include <stdio.h> #include <stdlib.h> #include <limits.h> typedef int Status; #define OK 1 #define ERROR 0 typedef int VR...
图的邻接矩阵表示法&邻接表表示法
大力海棠的博客
06-25 9272
图表示是一种多对多的关系的数据结构。因为线性表表示的是一种一对一的关系的数据结构，树表示的是一种一对多的数据结构，所以图把线性表和树都包含在内。图由一个非空的有限顶点集合和一个有限边集合组成。当我们描述图的时候，一定要包含以下两个元素：1、一组顶点：例如用Vertex表示顶点的集合。2、一组边：用Edge表示边的集合，一条边是一组顶点对。      •无向边 ：（i，j）∈Edge，i，j∈Ver...
看数据结构写代码（35） 图的邻接矩阵表示法
fuming0210sc的专栏
04-08 1652
杂谈：最近清明小长假，好好的放松了一下。节前 和 节后 都有点 松懈。不好，不好。贵在坚持。加油。 图的邻接矩阵表示法是用 两个数组 来表示 图的数据结构。一个是顶点数组，另一个是邻接矩阵数组。邻接矩阵 里存放着 顶点的关系。 用邻接矩阵表示图，在 看 顶点之间 是否有边，或者 求顶点的度等操作时比较简单。但空间浪费巨大，在插入，删除 顶点 和边 操作时 需要 移动大量数据，造成不便。所以在插
如何用c语言邻接矩阵表示法建立无向图
05-20
邻接矩阵是一种用于表示图的数据结构，其中矩阵中的每个元素表示两个顶点之间是否存在边。对于无向图而言，矩阵是对称的。 以下是使用C语言邻接矩阵表示法建立无向图的示例代码： ```c #include <stdio.h> #define MAX_VERTEX_NUM 20 // 邻接矩阵无向图结构体 typedef struct { char vertices[MAX_VERTEX_NUM]; // 顶点表 int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 邻接矩阵 int vertex_num; // 顶点数 int edge_num; // 边数 } MGraph; // 初始化无向图 void InitMGraph(MGraph *G) { int i, j; printf("请输入顶点数和边数：\n"); scanf("%d %d", &G->vertex_num, &G->edge_num); fflush(stdin); printf("请输入顶点信息：\n"); for (i = 0; i < G->vertex_num; i++) { scanf("%c", &G->vertices[i]); fflush(stdin); } // 初始化邻接矩阵 for (i = 0; i < G->vertex_num; i++) { for (j = 0; j < G->vertex_num; j++) { G->arcs[i][j] = 0; } } // 构建邻接矩阵 printf("请输入每条边的起点和终点：\n"); for (i = 0; i < G->edge_num; i++) { int v1, v2; scanf("%d %d", &v1, &v2); G->arcs[v1][v2] = 1; G->arcs[v2][v1] = 1; } } // 打印无向图 void PrintMGraph(MGraph G) { int i, j; printf("邻接矩阵：\n"); for (i = 0; i < G.vertex_num; i++) { for (j = 0; j < G.vertex_num; j++) { printf("%d ", G.arcs[i][j]); } printf("\n"); } } int main() { MGraph G; InitMGraph(&G); PrintMGraph(G); return 0; } ``` 在上面的代码中，我们定义了一个 `MGraph` 结构体来表示邻接矩阵无向图。`InitMGraph` 函数用于初始化图，包括输入顶点数、边数、顶点信息以及每条边的起点和终点，并构建邻接矩阵。`PrintMGraph` 函数用于打印邻接矩阵。在 `main` 函数中，我们调用 `InitMGraph` 和 `PrintMGraph` 函数来构建并打印无向图。 注意，上面的代码中，我们假设顶点使用字符表示，因此在输入顶点信息时使用了 `%c` 格式化符号。如果顶点使用其他类型表示，需要相应更改输入和打印的代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值