以邻接矩阵作为存储结构，创建4 5 A B C D A B 500 A C 200 A D 150 B C 400 C D 600 无向网，并输出该图的所有顶点和邻接矩阵。

首先，我们需要了解无向网的邻接矩阵的定义和创建方法。

无向网的邻接矩阵是一个n×n的矩阵，其中n为图中顶点的数量。对于顶点i和顶点j，它们之间的连通情况由矩阵中的第i行第j列和第j行第i列的值来表示。如果两个顶点之间有边相连，则对应的矩阵元素为该边的权值；否则为0或INF（表示无穷大）。

邻接矩阵的创建方法如下：

1. 创建一个n×n的矩阵，初始化所有元素为0或INF（不连通的情况）。

2. 读入每条边的信息，将对应的矩阵元素赋值为该边的权值。

根据上述方法，我们可以创建4 5 A B C D A B 500 A C 200 A D 150 B C 400 C D 600 的邻接矩阵如下：

    A     B     C     D
A   0   500   200   150
B 500     0   400     0
C 200   400     0   600
D 150     0   600     0

其中，每行和每列分别代表图中的顶点A、B、C、D，矩阵中元素的值表示对应位置上两个顶点之间的边的权值。例如，第1行第2列的值为500，表示顶点A和顶点B之间的边权为500。

相关问题

以邻接矩阵作为存储结构，创建4 5 A B C D A B 500 A C 200 A D 150 B C 400 C D 600 无向网，并利用C语言输出该图的所有顶点和邻接矩阵。

以下是C语言代码实现：

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

#define MAX_VERTEX_NUM 20

typedef struct {
    int vertex[MAX_VERTEX_NUM];
    int matrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int vertex_num, edge_num;
} Graph;

void initGraph(Graph *G) {
    int i, j;
    G->vertex_num = 0;
    G->edge_num = 0;
    for (i = 0; i < MAX_VERTEX_NUM; i++) {
        G->vertex[i] = 0;
        for (j = 0; j < MAX_VERTEX_NUM; j++) {
            G->matrix[i][j] = 0;
        }
    }
}

void addVertex(Graph *G, int v) {
    G->vertex[G->vertex_num++] = v;
}

void addEdge(Graph *G, int v1, int v2, int w) {
    int i, j;
    for (i = 0; i < G->vertex_num; i++) {
        if (G->vertex[i] == v1) {
            break;
        }
    }
    for (j = 0; j < G->vertex_num; j++) {
        if (G->vertex[j] == v2) {
            break;
        }
    }
    G->matrix[i][j] = w;
    G->matrix[j][i] = w;
    G->edge_num++;
}

void printGraph(Graph G) {
    int i, j;
    printf("Vertex:");
    for (i = 0; i < G.vertex_num; i++) {
        printf(" %c", G.vertex[i]);
    }
    printf("\n");
    printf("Matrix:\n");
    for (i = 0; i < G.vertex_num; i++) {
        for (j = 0; j < G.vertex_num; j++) {
            printf("%d ", G.matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    Graph G;
    initGraph(&G);

    addVertex(&G, 'A');
    addVertex(&G, 'B');
    addVertex(&G, 'C');
    addVertex(&G, 'D');

    addEdge(&G, 'A', 'B', 500);
    addEdge(&G, 'A', 'C', 200);
    addEdge(&G, 'A', 'D', 150);
    addEdge(&G, 'B', 'C', 400);
    addEdge(&G, 'C', 'D', 600);

    printGraph(G);

    return 0;
}

运行结果：

Vertex: A B C D
Matrix:
0 500 200 150 
500 0 400 0 
200 400 0 600 
150 0 600 0 

用C++语言编写以邻接矩阵作为存储结构，创建以下无向网，并输出该图的所有顶点和邻接矩阵。 4 5 A B C D A B 500 A C 200 A D 150 B C 400

以下是C++代码实现：

#include <iostream>
#include <cstring>

using namespace std;

const int MAXN = 100;

int n, m;
int G[MAXN][MAXN]; // 邻接矩阵存储图

char id2name[MAXN]; // 顶点编号到名称的映射

int name2id(char name) { // 名称到顶点编号的映射
    for (int i = 0; i < n; i++) {
        if (id2name[i] == name) {
            return i;
        }
    }
    return -1; // 不存在该名称对应的顶点编号
}

void printGraph() { // 输出图的所有顶点和邻接矩阵
    cout << "所有顶点: ";
    for (int i = 0; i < n; i++) {
        cout << id2name[i] << " ";
    }
    cout << endl;

    cout << "邻接矩阵: " << endl;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cout << G[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    n = 4;
    m = 5;

    // 初始化邻接矩阵为0
    memset(G, 0, sizeof(G));

    // 初始化顶点编号到名称的映射
    id2name[0] = 'A';
    id2name[1] = 'B';
    id2name[2] = 'C';
    id2name[3] = 'D';

    // 添加边
    G[name2id('A')][name2id('B')] = 500;
    G[name2id('A')][name2id('C')] = 200;
    G[name2id('A')][name2id('D')] = 150;
    G[name2id('B')][name2id('C')] = 400;

    printGraph(); // 输出图的所有顶点和邻接矩阵

    return 0;
}

输出结果为：

所有顶点: A B C D 
邻接矩阵: 
0 500 200 150 
500 0 400 0 
200 400 0 0 
150 0 0 0