用c语言以邻接矩阵为存储结构建立无向图并输出

好的，下面是用C语言实现以邻接矩阵为存储结构建立无向图并输出的示例代码：

#include <stdio.h>

#define MAXN 100

int a[MAXN][MAXN]; // 邻接矩阵
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); // 输入边的起点和终点
        a[u][v] = a[v][u] = 1; // 在邻接矩阵中标记两个节点之间有边
    }

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

    return 0;
}

在这个示例代码中，我们首先输入节点数和边数，然后依次输入每条边的起点和终点，并在邻接矩阵中标记两个节点之间有边。最后，我们遍历整个邻接矩阵，将每个元素输出到屏幕上，从而得到了这个无向图的邻接矩阵表示。

希望这个示例代码可以帮助你理解如何用C语言实现邻接矩阵存储结构的无向图，并输出它的邻接矩阵。如果你还有其他问题，欢迎随时向我提问。

相关问题

C语言实现邻接矩阵作为存储结构的无向图各顶点的度

好的，我可以帮你回答这个问题。

假设你已经定义了邻接矩阵的数据结构，可以按照以下步骤计算无向图各顶点的度数：

1. 定义一个数组degree，用于存储每个顶点的度数。
2. 遍历邻接矩阵的每一行，对于每一行i，计算该行中1的个数，即为顶点i的度数。
3. 将每个顶点的度数存储到degree数组中，即degree[i] = 顶点i的度数。
4. 遍历degree数组，输出每个顶点的度数即可。

以下是C语言代码示例：

#include <stdio.h>

#define MAX_VERTEX_NUM 100

typedef struct {
    int vertex[MAX_VERTEX_NUM]; // 存储顶点的数组
    int edge[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 存储邻接矩阵的二维数组
    int vertex_num; // 顶点数
    int edge_num; // 边数
} Graph;

void calc_degree(Graph* graph, int* degree) {
    for (int i = 0; i < graph->vertex_num; i++) {
        int count = 0;
        for (int j = 0; j < graph->vertex_num; j++) {
            if (graph->edge[i][j] == 1) {
                count++;
            }
        }
        degree[i] = count;
    }
}

int main() {
    Graph graph = {
        {0, 1, 2, 3, 4}, // 顶点数组
        { // 邻接矩阵
            {0, 1, 1, 0, 0},
            {1, 0, 1, 1, 0},
            {1, 1, 0, 0, 1},
            {0, 1, 0, 0, 1},
            {0, 0, 1, 1, 0}
        },
        5, // 顶点数
        7 // 边数
    };

    int degree[MAX_VERTEX_NUM];
    calc_degree(&graph, degree);

    printf("各顶点的度数为：\n");
    for (int i = 0; i < graph.vertex_num; i++) {
        printf("顶点%d的度数为：%d\n", graph.vertex[i], degree[i]);
    }

    return 0;
}

输出结果为：

各顶点的度数为：
顶点0的度数为：2
顶点1的度数为：3
顶点2的度数为：3
顶点3的度数为：2
顶点4的度数为：2

用C语言以邻接矩阵为存储结构，对无向图分别进行DFS（深度优先遍历）和BFS

首先，需要定义一个邻接矩阵来存储图。假设无向图有n个节点，则邻接矩阵是一个n * n的二维数组，其中matrix[i][j]表示节点i和节点j之间是否有边相连。如果有，则为1，否则为0。

下面是DFS算法的C语言代码实现：

#define MAX_NODE_NUM 100 // 假设最多有100个节点

int matrix[MAX_NODE_NUM][MAX_NODE_NUM]; // 邻接矩阵
int visited[MAX_NODE_NUM]; // 标记数组，表示节点是否被访问过

void dfs(int node, int n) {
    printf("%d ", node); // 输出当前节点
    visited[node] = 1; // 标记当前节点已经被访问过
    for (int i = 0; i < n; i++) { // 遍历与当前节点相邻的所有节点
        if (matrix[node][i] == 1 && visited[i] == 0) { // 如果节点i与当前节点有边相连且节点i未被访问过
            dfs(i, n); // 递归访问节点i
        }
    }
}

void dfsTraversal(int n) {
    memset(visited, 0, sizeof(visited)); // 初始化标记数组
    for (int i = 0; i < n; i++) { // 对每一个节点进行DFS遍历
        if (visited[i] == 0) { // 如果节点i未被访问过
            dfs(i, n); // 从节点i开始进行DFS遍历
        }
    }
}

下面是BFS算法的C语言代码实现：

#define MAX_NODE_NUM 100 // 假设最多有100个节点

int matrix[MAX_NODE_NUM][MAX_NODE_NUM]; // 邻接矩阵
int visited[MAX_NODE_NUM]; // 标记数组，表示节点是否被访问过

void bfs(int start, int n) {
    int queue[MAX_NODE_NUM], front = 0, rear = 0; // 定义队列
    queue[rear++] = start; // 将起始节点加入队列
    visited[start] = 1; // 标记起始节点已经被访问过
    while (front < rear) { // 队列非空
        int node = queue[front++]; // 取出队头元素
        printf("%d ", node); // 输出当前节点
        for (int i = 0; i < n; i++) { // 遍历与当前节点相邻的所有节点
            if (matrix[node][i] == 1 && visited[i] == 0) { // 如果节点i与当前节点有边相连且节点i未被访问过
                queue[rear++] = i; // 将节点i加入队列
                visited[i] = 1; // 标记节点i已经被访问过
            }
        }
    }
}

void bfsTraversal(int n) {
    memset(visited, 0, sizeof(visited)); // 初始化标记数组
    for (int i = 0; i < n; i++) { // 对每一个节点进行BFS遍历
        if (visited[i] == 0) { // 如果节点i未被访问过
            bfs(i, n); // 从节点i开始进行BFS遍历
        }
    }
}