CreateUDG(MGraph &G, int vexnum, int arcnum, char *vexs, int *arcs)这个函数如何使用
时间: 2024-03-05 11:55:05 浏览: 92
使用该函数创建一个无向图的步骤如下:
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;
}
```
需要注意的是,这只是一个示例代码,实际使用时需要根据具体需求进行修改和优化。
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即表示创建完成的无向图。
阅读全文