使用C++语言通过邻接矩阵的的的输入，输出无向图

可以通过以下代码实现：

#include <iostream>
using namespace std;

const int MAXN = 100; // 最大顶点数
int G[MAXN][MAXN]; // 邻接矩阵

int main() {
    int n, m; // n: 顶点数，m: 边数
    cin >> n >> m;
    for (int i = 1; i <= m; i++) {
        int u, v;
        cin >> u >> v;
        G[u][v] = G[v][u] = 1; // 无向图，所以要反向设置
    }

    // 输出邻接矩阵
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            cout << G[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

其中，输入的第一行为顶点数n和边数m，接下来m行为每条边的起点和终点。输出为邻接矩阵，其中1表示有边相连，0表示无边相连。

相关问题

C++语言，利用邻接矩阵创建无向图实现DFS和BFS

下面是基于邻接矩阵实现的DFS和BFS代码：

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

#define MAX_VERTEX_NUM 100

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

typedef struct Queue {
    int data[MAX_VERTEX_NUM];
    int front, rear;
} Queue;

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

// 判断队列是否为空
bool IsQueueEmpty(Queue* queue) {
    return queue->front == queue->rear;
}

// 入队
bool EnQueue(Queue* queue, int x) {
    if ((queue->rear + 1) % MAX_VERTEX_NUM == queue->front) {
        return false;
    }
    queue->data[queue->rear] = x;
    queue->rear = (queue->rear + 1) % MAX_VERTEX_NUM;
    return true;
}

// 出队
bool DeQueue(Queue* queue, int* x) {
    if (IsQueueEmpty(queue)) {
        return false;
    }
    *x = queue->data[queue->front];
    queue->front = (queue->front + 1) % MAX_VERTEX_NUM;
    return true;
}

// 初始化图
void InitGraph(Graph* graph) {
    int i, j;
    printf("输入顶点数和边数：");
    scanf("%d%d", &graph->vertex_num, &graph->edge_num);
    for (i = 0; i < graph->vertex_num; ++i) {
        printf("输入第%d个顶点的值：", i);
        scanf("%d", &graph->vertex[i]);
    }
    for (i = 0; i < graph->vertex_num; ++i) {
        for (j = 0; j < graph->vertex_num; ++j) {
            graph->matrix[i][j] = 0;
        }
    }
    for (i = 0; i < graph->edge_num; ++i) {
        int v1, v2;
        printf("输入第%d条边的起点和终点：", i);
        scanf("%d%d", &v1, &v2);
        graph->matrix[v1][v2] = 1;
        graph->matrix[v2][v1] = 1;
    }
}

// DFS遍历
void DFS(Graph* graph, bool* visited, int v) {
    int i;
    printf("%d ", graph->vertex[v]);
    visited[v] = true;
    for (i = 0; i < graph->vertex_num; ++i) {
        if (graph->matrix[v][i] == 1 && !visited[i]) {
            DFS(graph, visited, i);
        }
    }
}

// BFS遍历
void BFS(Graph* graph, bool* visited, Queue* queue, int v) {
    int i;
    printf("%d ", graph->vertex[v]);
    visited[v] = true;
    EnQueue(queue, v);
    while (!IsQueueEmpty(queue)) {
        int u;
        DeQueue(queue, &u);
        for (i = 0; i < graph->vertex_num; ++i) {
            if (graph->matrix[u][i] == 1 && !visited[i]) {
                printf("%d ", graph->vertex[i]);
                visited[i] = true;
                EnQueue(queue, i);
            }
        }
    }
}

int main() {
    Graph graph;
    bool visited[MAX_VERTEX_NUM];
    Queue queue;
    int i;
    InitGraph(&graph);
    for (i = 0; i < graph.vertex_num; ++i) {
        visited[i] = false;
    }
    printf("DFS遍历结果：");
    for (i = 0; i < graph.vertex_num; ++i) {
        if (!visited[i]) {
            DFS(&graph, visited, i);
        }
    }
    printf("\n");
    for (i = 0; i < graph.vertex_num; ++i) {
        visited[i] = false;
    }
    InitQueue(&queue);
    printf("BFS遍历结果：");
    for (i = 0; i < graph.vertex_num; ++i) {
        if (!visited[i]) {
            BFS(&graph, visited, &queue, i);
        }
    }
    printf("\n");
    return 0;
}

这里利用邻接矩阵存储图结构，实现了DFS和BFS遍历算法。在程序中，首先通过InitGraph函数读入图的顶点数、边数以及每个顶点的值，然后通过邻接矩阵表示图的连通关系。DFS和BFS遍历时，都需要记录每个节点是否已经被访问过，因此定义了visited数组用于记录。DFS遍历采用递归方式，而BFS遍历则利用队列实现。

如何用C++代码实现邻接矩阵表示的无向图和有向图，并展示它们的构建过程？

在学习图的表示方法时，邻接矩阵是一个不可或缺的概念。对于C++初学者来说，掌握如何构建邻接矩阵来表示无向图和有向图是非常重要的。这里，我们以《C++实现：邻接矩阵与邻接表的无向图/有向图构造与输出》为例，详细说明如何通过代码实现这两种图的构造。

参考资源链接：[C++实现：邻接矩阵与邻接表的无向图/有向图构造与输出](https://wenku.csdn.net/doc/89kedgjiyh?spm=1055.2569.3001.10343)

首先，我们需要定义一个二维数组来表示邻接矩阵，数组的大小为顶点数的平方。在无向图中，由于图的对称性，邻接矩阵是对称的，即`matrix[i][j]`与`matrix[j][i]`是相同的。而在有向图中，这两个位置的值可以是不同的，因为边是有方向的。

下面是一个简单的C++代码示例，展示如何构建一个无向图的邻接矩阵：

#include <iostream>
#define MAX_VERTICES 5 // 最大顶点数
using namespace std;

int graph[MAX_VERTICES][MAX_VERTICES]; // 邻接矩阵

void initializeGraph() {
    int i, j;
    for (i = 0; i < MAX_VERTICES; i++) {
        for (j = 0; j < MAX_VERTICES; j++) {
            graph[i][j] = 0; // 初始化邻接矩阵
        }
    }
}

void addEdge(int v1, int v2) {
    // 添加无向图的边
    graph[v1][v2] = 1; // 假设边没有权重
    graph[v2][v1] = 1; // 无向图的对称性
}

int main() {
    initializeGraph();
    addEdge(0, 1); // 添加边(顶点0, 顶点1)
    addEdge(1, 2); // 添加边(顶点1, 顶点2)
    // 输出邻接矩阵
    for (int i = 0; i < MAX_VERTICES; i++) {
        for (int j = 0; j < MAX_VERTICES; j++) {
            cout << graph[i][j] << 

参考资源链接：[C++实现：邻接矩阵与邻接表的无向图/有向图构造与输出](https://wenku.csdn.net/doc/89kedgjiyh?spm=1055.2569.3001.10343)