你好，请用C++帮我写一个邻接矩阵的代码

当然可以，以下是一个简单的邻接矩阵实现的代码：

#include <stdio.h>

#define MAXN 100 // 最大顶点数

int G[MAXN][MAXN]; // 邻接矩阵
int n, m; // n 个顶点，m 条边

int main() {
    scanf("%d%d", &n, &m); // 读入顶点数和边数
    for (int i = 0; i < m; ++i) {
        int u, v;
        scanf("%d%d", &u, &v); // 读入一条边的两个端点
        G[u][v] = G[v][u] = 1; // 在邻接矩阵中储存边的信息
    }
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            printf("%d ", G[i][j]); // 输出邻接矩阵
        }
        printf("\n");
    }
    return 0;
}

这个代码可以读入一个无向图的顶点数和边数，再依次读入每一条边的两个端点，最后输出邻接矩阵。在邻接矩阵中，若第 i 行 j 列为 1，代表第 i 个顶点和第 j 个顶点之间有一条边，否则为 0。

相关问题

你好，请用C++语言，帮我写一个邻接矩阵的代码

当然可以，以下是邻接矩阵的 C 语言代码：

#include <stdio.h>

#define MAX_N 100

int graph[MAX_N][MAX_N]; // 邻接矩阵
int n; // 图中节点数量

// 添加一条从 u 到 v 的有向边，如果带有边权，可以在参数中添加第三个参数
void add_edge(int u, int v) {
    graph[u][v] = 1;
}

// 输出邻接矩阵
void print_graph() {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", graph[i][j]);
        }
        printf("\n");
    }
}

int main() {
    // 初始化邻接矩阵
    for (int i = 0; i < MAX_N; i++) {
        for (int j = 0; j < MAX_N; j++) {
            graph[i][j] = 0; // 初始时，没有边相连
        }
    }

    // 添加一些边
    n = 5; // 五个节点
    add_edge(0, 1);
    add_edge(0, 2);
    add_edge(1, 2);
    add_edge(1, 3);
    add_edge(2, 3);
    add_edge(3, 4);

    // 输出邻接矩阵
    print_graph();

    return 0;
}

为了方便说明，上述代码会输出一个 5 个节点的无向图的邻接矩阵。在实际使用中，你需要根据实际问题进行修改。

请用C++语言写一个基于邻接矩阵的广度优先遍历

下面是基于邻接矩阵的广度优先遍历的 C 语言代码：

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

#define MAX_VERTEX_NUM 100 // 最大顶点数

typedef int VertexType; // 顶点类型为整型
typedef int EdgeType; // 边权值类型为整型

typedef struct {
    VertexType vertex[MAX_VERTEX_NUM]; // 存储顶点信息
    EdgeType edge[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 存储边权值
    int vertexNum; // 顶点数目
    int edgeNum; // 边数目
} MGraph;

typedef struct {
    int data[MAX_VERTEX_NUM]; // 存储队列元素
    int front; // 队头指针
    int rear; // 队尾指针
} Queue;

// 初始化队列
void initQueue(Queue *q) {
    q->front = q->rear = 0;
}

// 判断队列是否为空
int isQueueEmpty(Queue *q) {
    return q->front == q->rear;
}

// 入队
int enqueue(Queue *q, int x) {
    if ((q->rear + 1) % MAX_VERTEX_NUM == q->front) { // 队列已满
        return 0;
    }
    q->data[q->rear] = x;
    q->rear = (q->rear + 1) % MAX_VERTEX_NUM;
    return 1;
}

// 出队
int dequeue(Queue *q, int *x) {
    if (isQueueEmpty(q)) { // 队列为空
        return 0;
    }
    *x = q->data[q->front];
    q->front = (q->front + 1) % MAX_VERTEX_NUM;
    return 1;
}

// 建立无向图的邻接矩阵
void createUndirectedGraph(MGraph *G) {
    printf("请输入顶点数和边数：\n");
    scanf("%d %d", &(G->vertexNum), &(G->edgeNum));
    printf("请输入顶点信息：\n");
    for (int i = 0; i < G->vertexNum; i++) {
        scanf("%d", &(G->vertex[i]));
    }
    for (int i = 0; i < G->vertexNum; i++) {
        for (int j = 0; j < G->vertexNum; j++) {
            G->edge[i][j] = 0; // 初始化边权值为0
        }
    }
    printf("请输入边的信息：\n");
    for (int k = 0; k < G->edgeNum; k++) {
        int i, j;
        scanf("%d %d", &i, &j);
        G->edge[i][j] = G->edge[j][i] = 1; // 无向图的边是对称的
    }
}

// 广度优先遍历
void BFS(MGraph G, int v) {
    int visited[MAX_VERTEX_NUM] = {0}; // 标记顶点是否被访问过
    Queue q;
    initQueue(&q);
    visited[v] = 1; // 访问起始顶点v
    printf("%d ", G.vertex[v]);
    enqueue(&q, v); // v进队列
    while (!isQueueEmpty(&q)) {
        int u;
        dequeue(&q, &u); // 队头元素出队列
        for (int i = 0; i < G.vertexNum; i++) {
            if (G.edge[u][i] == 1 && visited[i] == 0) { // u和i之间有边且i未被访问过
                visited[i] = 1; // 访问顶点i
                printf("%d ", G.vertex[i]);
                enqueue(&q, i); // i进队列
            }
        }
    }
}

int main() {
    MGraph G;
    createUndirectedGraph(&G);
    printf("请输入起始顶点：\n");
    int v;
    scanf("%d", &v);
    printf("广度优先遍历结果为：\n");
    BFS(G, v);
    printf("\n");
    return 0;
}