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

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

首先，邻接矩阵是一种常用的图的存储结构，它可以用一个二维数组来表示图中各个节点之间的关系。对于无向图来说，邻接矩阵是一个对称矩阵，因为节点之间的关系是相互的。

接下来，我会提供一个简单的C语言代码来实现用邻接矩阵为存储结构建立无向图。假设有n个节点，我们可以用一个n x n的二维数组来存储节点之间的关系，其中a[i][j]表示节点i与节点j之间是否有边。如果有边，a[i][j]为1，否则为0。

#include<stdio.h>
#define MAXN 1000
int a[MAXN][MAXN];

int main()
{
    int n,m;
    scanf("%d%d",&n,&m); //输入节点数和边数
    for(int i=1;i<=m;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v); //输入边的起点和终点
        a[u][v]=a[v][u]=1; //在邻接矩阵中标记两个节点之间有边
    }
    return 0;
}

在上面的代码中，我们首先输入节点数和边数，然后通过循环依次输入每条边的起点和终点，最后在邻接矩阵中标记这两个节点之间有边。这样，我们就成功建立了一个无向图的邻接矩阵表示。

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

相关问题

用c语言以邻接矩阵形式创建一个无向图并 以邻接表的形式创建一个无向图。

创建无向图邻接矩阵的C语言代码：

#include <stdio.h>
#define MAXV 100    // 最大顶点数

typedef struct {
    int matrix[MAXV][MAXV]; // 邻接矩阵
    int num_v;  // 顶点数
} Graph;

void init(Graph *G, int num_v) {
    G->num_v = num_v;
    for (int i = 0; i < num_v; i++) {
        for (int j = 0; j < num_v; j++) {
            G->matrix[i][j] = 0;    // 初始化为0
        }
    }
}

void addEdge(Graph *G, int u, int v) {
    G->matrix[u][v] = 1;
    G->matrix[v][u] = 1;    // 无向图，所以需要反向再赋值一次
}

void printGraph(Graph *G) {
    for (int i = 0; i < G->num_v; i++) {
        printf("%d: ", i);
        for (int j = 0; j < G->num_v; j++) {
            if (G->matrix[i][j]) {
                printf("%d ", j);
            }
        }
        printf("\n");
    }
}

int main() {
    Graph G;
    int num_v = 5;
    init(&G, num_v);
    addEdge(&G, 0, 1);
    addEdge(&G, 0, 4);
    addEdge(&G, 1, 2);
    addEdge(&G, 1, 3);
    addEdge(&G, 1, 4);
    addEdge(&G, 2, 3);
    addEdge(&G, 3, 4);
    printGraph(&G);
    return 0;
}

创建无向图邻接表的C语言代码：

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

typedef struct node {
    int v;  // 该边所连向的顶点
    struct node *next;  // 指向下一条边的指针
} EdgeNode;

typedef struct vnode {
    int data;   // 顶点信息
    EdgeNode *first_edge;   // 指向第一条依附于该顶点的边的指针
} VertexNode;

typedef struct {
    VertexNode adj_list[100];   // 邻接表，最多100个顶点
    int num_v, num_e;   // 顶点数和边数
} Graph;

void init(Graph *G, int num_v) {
    G->num_v = num_v;
    G->num_e = 0;
    for (int i = 0; i < num_v; i++) {
        G->adj_list[i].data = i;
        G->adj_list[i].first_edge = NULL;
    }
}

void addEdge(Graph *G, int u, int v) {
    EdgeNode *e = (EdgeNode *) malloc(sizeof(EdgeNode));
    e->v = v;
    e->next = G->adj_list[u].first_edge;
    G->adj_list[u].first_edge = e;

    e = (EdgeNode *) malloc(sizeof(EdgeNode));
    e->v = u;
    e->next = G->adj_list[v].first_edge;
    G->adj_list[v].first_edge = e;

    G->num_e++;
}

void printGraph(Graph *G) {
    for (int i = 0; i < G->num_v; i++) {
        printf("%d: ", G->adj_list[i].data);
        EdgeNode *e = G->adj_list[i].first_edge;
        while (e != NULL) {
            printf("%d ", e->v);
            e = e->next;
        }
        printf("\n");
    }
}

int main() {
    Graph G;
    int num_v = 5;
    init(&G, num_v);
    addEdge(&G, 0, 1);
    addEdge(&G, 0, 4);
    addEdge(&G, 1, 2);
    addEdge(&G, 1, 3);
    addEdge(&G, 1, 4);
    addEdge(&G, 2, 3);
    addEdge(&G, 3, 4);
    printGraph(&G);
    return 0;
}

c语言用邻接矩阵存储建立无向图，并求任一顶点的出处

好的，关于你的问题，我可以给你提供一些帮助。

在C语言中，我们可以使用邻接矩阵来存储无向图。具体地说，我们可以定义一个二维数组来表示该矩阵，其中矩阵的行和列分别对应图中的各个顶点。如果两个顶点之间有一条边，则相应的矩阵元素的值为1；否则为0。

接下来，我们可以使用深度优先搜索（DFS）或广度优先搜索（BFS）等算法来遍历整个图，并求出任一顶点的出度（即该顶点的度数，也就是与该顶点相邻的边的数量）。具体步骤如下：

1. 定义一个变量 count，用于统计该顶点的出度，初始值为0。

2. 遍历该顶点所在的行（或列），对于每个非零元素，将 count 的值加1。

3. 最终 count 的值即为该顶点的出度。

下面是一个示例代码，其中假设邻接矩阵已经定义为一个名为 graph 的二维数组，顶点的编号从1开始，要求统计第2个顶点的出度：

#include <stdio.h>

#define MAX_VERTICES 100

int graph[MAX_VERTICES][MAX_VERTICES]; // 邻接矩阵表示的图
int num_vertices; // 顶点数

int outdegree(int v) // 计算顶点v的出度
{
    int count = 0;
    for (int i = 0; i < num_vertices; i++) {
        if (graph[v - 1][i] != 0) {
            count++;
        }
    }
    return count;
}

int main()
{
    // 假设图已经建立，并且顶点数为 num_vertices

    int v = 2; // 要求统计出度的顶点编号为2
    int degree = outdegree(v);
    printf("Vertex %d has outdegree %d\n", v, degree);

    return 0;
}

希望这些信息对你有所帮助！如果你有其他问题，可以继续问我。