void CreateUDG(MGraph &G, int vexnum, int arcnum, char *vexs, int *arcs) { int i, j, k; G.vexnum = vexnum; G.arcnum = arcnum; memcpy(G.vexs, vexs, G.vexnum * sizeof(char)); memset(G.arcs, 0, sizeof(G.arcs)); for (k = 0; k < G.arcnum; k++) { i = arcs[k * 2] - 'A'; j = arcs[k * 2 + 1] - 'A'; G.arcs[i][j].adj = 1; G.arcs[j][i].adj = 1; } }解释一下这段代码

这段代码定义了一个函数CreateUDG，用于创建一个无向图。函数的参数包括：一个MGraph类型的结构体变量G，表示要创建的无向图；一个整型变量vexnum，表示无向图的顶点数；一个整型变量arcnum，表示无向图的边数；一个字符数组vexs，表示无向图的顶点集合；一个整型数组arcs，表示无向图的边集合。

函数体中，首先将传入的顶点集合vexs复制到G结构体变量中对应的顶点集合中。然后，将图的邻接矩阵G.arcs中所有元素初始化为0，表示暂时没有边相连。接下来，使用循环遍历无向图的边集合，对于每一条边，将其起点和终点分别转换成对应的下标i和j，然后将邻接矩阵中i和j位置的元素赋值为1，表示这两个顶点之间有一条边。由于是无向图，所以还需要将邻接矩阵中j和i位置的元素同样赋值为1。最终，函数执行完毕后，变量G即表示创建完成的无向图。

相关问题

CreateUDG(MGraph &G, int vexnum, int arcnum, char *vexs, int *arcs)这个函数如何使用

使用该函数创建一个无向图的步骤如下：

1. 定义一个MGraph类型的结构体变量G，用于存储创建的无向图。

2. 定义一个字符数组vexs，用于存储无向图的顶点集合，数组大小为vexnum。

3. 定义一个整型数组arcs，用于存储无向图的边集合，数组大小为arcnum。

4. 调用CreateUDG函数，将G、vexnum、arcnum、vexs、arcs作为参数传入。

5. 执行完CreateUDG函数后，变量G中存储的即为创建完成的无向图。

例如，如果想要创建一个5个顶点6条边的无向图，可以按照以下步骤：

MGraph G;
char vexs[] = {'A', 'B', 'C', 'D', 'E'};
int arcs[] = {0, 1, 0, 2, 0, 3, 1, 2, 2, 3, 3, 4};
CreateUDG(G, 5, 6, vexs, arcs);

其中，顶点集合为{'A', 'B', 'C', 'D', 'E'}，边集合为{(0,1), (0,2), (0,3), (1,2), (2,3), (3,4)}，其中的数字表示顶点在vexs数组中的下标。执行完毕后，变量G即为创建完成的无向图。

编写一个能够创建4种不同类型图的邻接矩阵存储的通用函数，函数格式如下： CreateMGraph(GraphKind GKind, MGraph &G, int vexnum, int arcnum, char *vexs, int *arcs)

以下是一个创建4种不同类型图的邻接矩阵存储的通用函数的示例代码，其中包括无向图、有向图、无向带权图和有向带权图。

#include <iostream>
#include <cstring>

using namespace std;

#define MAXVEX 100 // 最大顶点数

// 边的结构体
typedef struct {
    int adj; // 顶点间是否有边
    int weight; // 权值
} ArcCell, AdjMatrix[MAXVEX][MAXVEX];

// 图的结构体
typedef struct {
    char vexs[MAXVEX]; // 顶点集合
    AdjMatrix arcs; // 邻接矩阵
    int vexnum, arcnum; // 顶点数和边数
    int kind; // 图的类型
} MGraph;

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

// 创建无向图的邻接矩阵存储
void CreateUDG(MGraph &G, int vexnum, int arcnum, char *vexs, int *arcs) {
    int i, j, k;
    G.vexnum = vexnum;
    G.arcnum = arcnum;
    memcpy(G.vexs, vexs, G.vexnum * sizeof(char));
    memset(G.arcs, 0, sizeof(G.arcs));
    for (k = 0; k < G.arcnum; k++) {
        i = arcs[k * 2] - 'A';
        j = arcs[k * 2 + 1] - 'A';
        G.arcs[i][j].adj = 1;
        G.arcs[j][i].adj = 1;
    }
}

// 创建有向图的邻接矩阵存储
void CreateDG(MGraph &G, int vexnum, int arcnum, char *vexs, int *arcs) {
    int i, j, k;
    G.vexnum = vexnum;
    G.arcnum = arcnum;
    memcpy(G.vexs, vexs, G.vexnum * sizeof(char));
    memset(G.arcs, 0, sizeof(G.arcs));
    for (k = 0; k < G.arcnum; k++) {
        i = arcs[k * 2] - 'A';
        j = arcs[k * 2 + 1] - 'A';
        G.arcs[i][j].adj = 1;
    }
}

// 创建无向带权图的邻接矩阵存储
void CreateUDN(MGraph &G, int vexnum, int arcnum, char *vexs, int *arcs) {
    int i, j, k, w;
    G.vexnum = vexnum;
    G.arcnum = arcnum;
    memcpy(G.vexs, vexs, G.vexnum * sizeof(char));
    memset(G.arcs, 0, sizeof(G.arcs));
    for (k = 0; k < G.arcnum; k++) {
        i = arcs[k * 3] - 'A';
        j = arcs[k * 3 + 1] - 'A';
        w = arcs[k * 3 + 2];
        G.arcs[i][j].adj = 1;
        G.arcs[j][i].adj = 1;
        G.arcs[i][j].weight = w;
        G.arcs[j][i].weight = w;
    }
}

// 创建有向带权图的邻接矩阵存储
void CreateDN(MGraph &G, int vexnum, int arcnum, char *vexs, int *arcs) {
    int i, j, k, w;
    G.vexnum = vexnum;
    G.arcnum = arcnum;
    memcpy(G.vexs, vexs, G.vexnum * sizeof(char));
    memset(G.arcs, 0, sizeof(G.arcs));
    for (k = 0; k < G.arcnum; k++) {
        i = arcs[k * 3] - 'A';
        j = arcs[k * 3 + 1] - 'A';
        w = arcs[k * 3 + 2];
        G.arcs[i][j].adj = 1;
        G.arcs[i][j].weight = w;
    }
}

// 创建图的邻接矩阵存储
void CreateMGraph(GraphKind GKind, MGraph &G, int vexnum, int arcnum, char *vexs, int *arcs) {
    G.kind = GKind;
    switch (G.kind) {
        case UDG:
            CreateUDG(G, vexnum, arcnum, vexs, arcs);
            break;
        case DG:
            CreateDG(G, vexnum, arcnum, vexs, arcs);
            break;
        case UDN:
            CreateUDN(G, vexnum, arcnum, vexs, arcs);
            break;
        case DN:
            CreateDN(G, vexnum, arcnum, vexs, arcs);
            break;
        default:
            break;
    }
}

int main() {
    MGraph G;
    int vexnum = 5;
    int arcnum = 5;
    char vexs[MAXVEX] = {'A', 'B', 'C', 'D', 'E'};
    int arcs[20] = {0, 1, 0, 2, 1, 2, 1, 3, 2, 4};
    CreateMGraph(UDG, G, vexnum, arcnum, vexs, arcs);

    return 0;
}

需要注意的是，这只是一个示例代码，实际使用时需要根据具体需求进行修改和优化。