给定一个n个顶点（1到n编号）的无向图，以及若干条边，请对其构造邻接矩阵。c语言代码

好的，以下是一个使用 C 语言实现的构造邻接矩阵的示例代码：

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

#define MAX_N 100

int adj_matrix[MAX_N][MAX_N]; // 邻接矩阵
int n, m; // 顶点数和边数

int main() {
    scanf("%d%d", &n, &m); // 输入顶点数和边数
    for (int i = 0; i < m; i++) {
        int u, v;
        scanf("%d%d", &u, &v); // 输入一条边连接的两个顶点编号
        adj_matrix[u][v] = adj_matrix[v][u] = 1; // 在邻接矩阵中记录这条边
    }
    // 输出邻接矩阵
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            printf("%d ", adj_matrix[i][j]);
        }
        printf("\n");
    }
    return 0;
}

这个代码片段首先输入顶点数和边数，然后依次输入每条边连接的两个顶点编号，使用邻接矩阵记录每条边的信息。最后，遍历整个邻接矩阵，输出每个元素的值，即可得到完整的邻接矩阵。

希望对你有所帮助。

相关问题

给定一个n个顶点（1到n编号）的无向图，以及若干条边，请对其构造邻接矩阵。c语言

好的，以下是在C语言中构造邻接矩阵的示例代码（假设给定的边存储在一个二维数组中，每一行表示一条边，两个元素分别为边的两个顶点编号）：

#include <stdio.h>

#define MAX_N 1000

int adj_matrix[MAX_N][MAX_N];  // 定义邻接矩阵

int main() {
    int n, m;  // n为顶点数，m为边数
    scanf("%d%d", &n, &m);

    // 初始化邻接矩阵为全0
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            adj_matrix[i][j] = 0;
        }
    }

    // 读入边并标记邻接矩阵
    for (int i = 0; i < m; i++) {
        int u, v;
        scanf("%d%d", &u, &v);
        adj_matrix[u-1][v-1] = 1;  // 标记边的两个端点
        adj_matrix[v-1][u-1] = 1;
    }

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

    return 0;
}

希望能帮到您！

C语言代码建立一个无向图的邻接矩阵表示，实现对图的广度优先遍历

### 回答1：
以下是使用邻接矩阵表示无向图，并进行广度优先遍历的C语言代码：

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

#define MAX_VERTEX_NUM 20 // 最大顶点数

typedef enum {false, true} bool;

typedef struct {
    int vertex[MAX_VERTEX_NUM]; // 存储顶点信息
    int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 存储边的信息
    int vertex_num, arc_num; // 顶点数和边数
} Graph;

// 初始化图
void InitGraph(Graph *g) {
    int i, j;
    g->vertex_num = 0;
    g->arc_num = 0;
    for (i = 0; i < MAX_VERTEX_NUM; i++) {
        g->vertex[i] = 0;
        for (j = 0; j < MAX_VERTEX_NUM; j++) {
            g->arcs[i][j] = 0;
        }
    }
}

// 添加顶点
bool AddVertex(Graph *g, int v) {
    if (g->vertex_num >= MAX_VERTEX_NUM) {
        return false;
    }
    g->vertex[g->vertex_num++] = v;
    return true;
}

// 添加边
bool AddArc(Graph *g, int v1, int v2) {
    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;
        }
    }
    if (i == g->vertex_num || j == g->vertex_num) {
        return false;
    }
    g->arcs[i][j] = 1;
    g->arcs[j][i] = 1;
    g->arc_num++;
    return true;
}

// 广度优先遍历
void BFS(Graph *g, int v) {
    int queue[MAX_VERTEX_NUM], front = 0, rear = 0; // 队列
    bool visited[MAX_VERTEX_NUM]; // 标记是否已经访问
    int i, j, k;
    for (i = 0; i < g->vertex_num; i++) {
        visited[i] = false;
    }
    visited[v] = true; // 访问初始顶点
    printf("%d ", g->vertex[v]);
    queue[rear++] = v; // 入队
    while (front < rear) { // 队列非空
        i = queue[front++]; // 出队
        for (j = 0; j < g->vertex_num; j++) {
            if (g->arcs[i][j] == 1 && !visited[j]) { // 与当前顶点相连且未被访问
                visited[j] = true;
                printf("%d ", g->vertex[j]);
                queue[rear++] = j; // 入队
            }
        }
    }
}

int main() {
    Graph g;
    int i;
    InitGraph(&g);
    AddVertex(&g, 0);
    AddVertex(&g, 1);
    AddVertex(&g, 2);
    AddVertex(&g, 3);
    AddVertex(&g, 4);
    AddArc(&g, 0, 1);
    AddArc(&g, 0, 2);
    AddArc(&g, 0, 3);
    AddArc(&g, 1, 2);
    AddArc(&g, 2, 3);
    AddArc(&g, 3, 4);
    printf("BFS: ");
    BFS(&g, 0);
    printf("\n");
    return 0;
}

该代码创建了一个邻接矩阵表示的无向图，并使用广度优先遍历算法遍历该图。其中，`InitGraph` 函数用于初始化图，`AddVertex` 函数用于添加顶点，`AddArc` 函数用于添加边，`BFS` 函数用于进行广度优先遍历。在 `main` 函数中，我们创建了一个包含 5 个顶点和 6 条边的无向图，并从顶点 0 开始进行广度优先遍历。

### 回答2：
要建立一个无向图的邻接矩阵表示，我们可以先定义一个二维数组来表示图的邻接关系。假设图有n个顶点，则我们可以用一个大小为n×n的矩阵来表示图的邻接关系，其中矩阵的元素a[i][j]表示顶点i和顶点j之间是否有边相连。如果有边相连，则a[i][j]的值为1，否则为0。

接下来，实现图的广度优先遍历算法。广度优先遍历是一种图的搜索算法，能够按照层次的顺序遍历图中的所有顶点，并且能够找到从给定起始节点到目标节点之间的最短路径。

广度优先遍历的核心思想是从起始节点开始，依次访问与起始节点直接相连的节点，并将这些节点加入到一个队列中。然后从队列中取出一个节点，继续访问与该节点直接相连的节点，并将这些节点加入到队列中，依此类推，直到队列为空。

首先，我们需要定义一个队列来保存待访问的节点。然后，我们从起始节点开始，将起始节点加入队列，并标记起始节点为已访问。接着，我们进入一个循环，将队列中的首个节点取出，并访问该节点。然后，我们遍历该节点的所有相邻节点，如果相邻节点未被访问过，则将其加入队列，并标记为已访问。最后，继续进行下一轮循环，直到队列为空。

以下是用C语言实现图的广度优先遍历的代码示例：

#include <stdio.h>
#define MAX_SIZE 100

int visited[MAX_SIZE]; // 用于标记节点是否已被访问
int queue[MAX_SIZE]; // 队列
int front = -1, rear = -1; // 队列的头和尾指针

void enqueue(int node) {
    if (rear == MAX_SIZE - 1) { // 队列已满
        printf("Queue is full\n");
        return;
    }
    if (front == -1) { // 队列为空
        front = rear = 0;
    } else {
        rear++;
    }
    queue[rear] = node;
}

int dequeue() {
    if (front == -1) { // 队列为空
        printf("Queue is empty\n");
        return -1;
    }
    int node = queue[front];
    if (front == rear) { // 队列中只有一个元素
        front = rear = -1;
    } else {
        front++;
    }
    return node;
}

void bfs(int graph[MAX_SIZE][MAX_SIZE], int n, int start) {
    enqueue(start);
    visited[start] = 1;
    
    while (front != -1) {
        int node = dequeue();
        printf("%d ", node);
        
        for (int i = 0; i < n; i++) {
            if (graph[node][i] == 1 && visited[i] == 0) {
                enqueue(i);
                visited[i] = 1;
            }
        }
    }
}

int main() {
    int n; // 图的顶点数
    printf("Enter the number of vertices: ");
    scanf("%d", &n);
    
    int graph[MAX_SIZE][MAX_SIZE]; // 图的邻接矩阵表示
    printf("Enter the adjacency matrix:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &graph[i][j]);
        }
    }
    
    int start; // 起始节点
    printf("Enter the starting vertex: ");
    scanf("%d", &start);
    
    printf("BFS traversal: ");
    bfs(graph, n, start);
    
    return 0;
}

以上就是用C语言实现图的邻接矩阵表示以及广度优先遍历算法的示例代码。