构造一个无向图（用邻接矩阵表示存储结构

好的，我来构造一个无向图，假设图中有5个顶点，分别为A、B、C、D、E，它们之间的边如下：

A和B相连，权值为2；

A和C相连，权值为3；

B和C相连，权值4；

B和D相连，权值为5；

C和D相连，权值为6；

C和E相连，权值为7；

D和E相连，权值为8。

邻接矩阵表示如下：

  A  B  C  D  E
A 0  2  3  0  0
B 2  0  4  5  0
C 3  4  0  6  7
D 0  5  6  0  8
E 0  0  7  8  0

其中，矩阵中的每个元素表示两个顶点之间的权值，若两个顶点之间没有边相连，则该元素为0。由于这是个无向图，所以矩阵是对称的。

相关问题

1.先依次输入无向图的顶点信息，再依次输入无向图的边信息，建立图的邻接矩阵存储结构并将其顶点向量和邻接矩阵打印输出： 3.在1中建立的无向图的邻接矩阵存储结构基础上使用递归法对图进行深度优先搜索遍历并输出顶点序列； 在1中建立的无向图邻接矩阵存储结构基础上 5.对图进行广度优先搜索遍历并输出顶点序列。用C语言表述

好的，我明白了。以下是代码实现：

#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTEX_NUM 20 // 最大顶点数

typedef char VertexType; // 定义顶点类型为字符型

typedef struct {
    VertexType vexs[MAX_VERTEX_NUM]; // 顶点向量
    int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 邻接矩阵
    int vexnum, arcnum; // 图的当前顶点数和边数
} MGraph; // 邻接矩阵存储结构

// 从键盘输入图的顶点信息和边信息，构造邻接矩阵存储结构
void CreateMGraph(MGraph* G) {
    printf("请输入顶点数和边数：");
    scanf("%d%d", &G->vexnum, &G->arcnum);
    getchar(); // 消耗换行符

    // 输入顶点向量
    printf("请输入%d个顶点的信息：", G->vexnum);
    for (int i = 0; i < G->vexnum; i++) {
        scanf("%c", &G->vexs[i]);
        getchar(); // 消耗换行符
    }

    // 初始化邻接矩阵
    for (int i = 0; i < G->vexnum; i++) {
        for (int j = 0; j < G->vexnum; j++) {
            G->arcs[i][j] = 0;
        }
    }

    // 输入边信息
    for (int k = 0; k < G->arcnum; k++) {
        printf("请输入第%d条边的两个端点：", k + 1);
        VertexType v1, v2;
        scanf("%c%c", &v1, &v2);
        getchar(); // 消耗换行符

        // 查找顶点位置
        int i, j;
        for (i = 0; i < G->vexnum; i++) {
            if (G->vexs[i] == v1) break;
        }
        for (j = 0; j < G->vexnum; j++) {
            if (G->vexs[j] == v2) break;
        }

        // 设置邻接矩阵
        G->arcs[i][j] = 1;
        G->arcs[j][i] = 1;
    }
}

// 输出邻接矩阵存储结构
void PrintMGraph(MGraph G) {
    printf("邻接矩阵为：\n");
    for (int i = 0; i < G.vexnum; i++) {
        for (int j = 0; j < G.vexnum; j++) {
            printf("%d ", G.arcs[i][j]);
        }
        printf("\n");
    }
    printf("顶点向量为：");
    for (int i = 0; i < G.vexnum; i++) {
        printf("%c ", G.vexs[i]);
    }
    printf("\n");
}

// 递归函数：从第i个顶点开始深度优先搜索遍历邻接矩阵存储的图
void DFS(MGraph G, int i, int* visited) {
    printf("%c ", G.vexs[i]); // 输出当前顶点
    visited[i] = 1; // 标记当前顶点已被访问
    for (int j = 0; j < G.vexnum; j++) {
        if (G.arcs[i][j] == 1 && visited[j] == 0) {
            DFS(G, j, visited);
        }
    }
}

// 深度优先搜索遍历图
void DFSTraverse(MGraph G) {
    printf("深度优先搜索遍历序列为：");
    int visited[MAX_VERTEX_NUM] = {0}; // 初始化所有顶点未被访问
    for (int i = 0; i < G.vexnum; i++) {
        if (visited[i] == 0) {
            DFS(G, i, visited);
        }
    }
    printf("\n");
}

// 广度优先搜索遍历图
void BFSTraverse(MGraph G) {
    printf("广度优先搜索遍历序列为：");
    int visited[MAX_VERTEX_NUM] = {0}; // 初始化所有顶点未被访问
    int queue[MAX_VERTEX_NUM]; // 定义辅助队列
    int front = 0, rear = 0; // 定义队头和队尾指针
    for (int i = 0; i < G.vexnum; i++) {
        if (visited[i] == 0) {
            printf("%c ", G.vexs[i]); // 输出当前顶点
            visited[i] = 1; // 标记当前顶点已被访问
            queue[rear++] = i; // 将当前顶点入队
            while (front < rear) { // 当队列非空时
                int j = queue[front++]; // 将队头元素出队
                for (int k = 0; k < G.vexnum; k++) {
                    if (G.arcs[j][k] == 1 && visited[k] == 0) {
                        printf("%c ", G.vexs[k]); // 输出当前顶点
                        visited[k] = 1; // 标记当前顶点已被访问
                        queue[rear++] = k; // 将当前顶点入队
                    }
                }
            }
        }
    }
    printf("\n");
}

int main() {
    MGraph G;
    CreateMGraph(&G);
    PrintMGraph(G);
    DFSTraverse(G);
    BFSTraverse(G);
    return 0;
}

注意：输入顶点信息时需要消耗掉输入缓冲区的换行符，否则会影响后面的输入。这里使用 `getchar()` 函数来消耗换行符。

邻接矩阵作为存储结构创建一个无向图

以下是使用邻接矩阵作为存储结构创建一个无向图的Python代码示例：

class Graph:
    def __init__(self, vertices):
        self.V = vertices
        self.graph = [[0] * self.V for _ in range(self.V)]

    def add_edge(self, u, v):
        self.graph[u][v] = 1
        self.graph[v][u] = 1

    def print_graph(self):
        for i in range(self.V):
            for j in range(self.V):
                print(self.graph[i][j], end=' ')
            print()

g = Graph(5)
g.add_edge(0, 1)
g.add_edge(0, 4)
g.add_edge(1, 2)
g.add_edge(1, 3)
g.add_edge(1, 4)
g.add_edge(2, 3)
g.add_edge(3, 4)

g.print_graph()

在这个例子中，我们首先定义了一个Graph类，它包含一个构造函数和两个方法。构造函数初始化了一个大小为V x V的邻接矩阵，其中V是图的顶点数。add_edge()方法用于将两个顶点之间的边添加到邻接矩阵中。print_graph()方法用于打印邻接矩阵。

在这个例子中，我们创建了一个大小为5的图，并添加了7条边。最后，我们打印了邻接矩阵。