无向图的建立，实现邻接表和邻接矩阵之间的转换，并输出图的C语言代码怎么写

建立无向图的过程可以通过输入顶点数和边数，以及每一条边的起点和终点来完成。邻接表和邻接矩阵是两种常见的图的存储方式，它们之间的转换可以通过遍历图中的每一个节点，将其邻接点在邻接表和邻接矩阵中的位置进行标记。

下面是建立无向图并实现邻接表和邻接矩阵之间的转换的示例代码：

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

#define MAX_VERTEX_NUM 100  // 最大顶点数

// 邻接表节点
typedef struct ArcNode {
    int adjvex;  // 邻接点编号
    struct ArcNode *next;  // 指向下一个邻接点
} ArcNode;

// 邻接表头节点
typedef struct VNode {
    char data;  // 顶点数据
    ArcNode *first;  // 指向第一个邻接点
} VNode, AdjList[MAX_VERTEX_NUM];

// 邻接表
typedef struct {
    AdjList vertices;  // 邻接表头数组
    int vexnum, arcnum;  // 顶点数和边数
} ALGraph;

// 邻接矩阵
typedef struct {
    int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];  // 存储图的二维数组
    char vexs[MAX_VERTEX_NUM];  // 存储顶点数据的一维数组
    int vexnum, arcnum;  // 顶点数和边数
} AMGraph;

// 从邻接表创建邻接矩阵
void createAMGraph(ALGraph *G, AMGraph *M) {
    int i, j;
    ArcNode *p;
    M->vexnum = G->vexnum;
    M->arcnum = G->arcnum;
    for (i = 0; i < G->vexnum; i++) {
        M->vexs[i] = G->vertices[i].data;
        for (j = 0; j < G->vexnum; j++) {
            M->arcs[i][j] = 0;
        }
        p = G->vertices[i].first;
        while (p) {
            M->arcs[i][p->adjvex] = 1;
            p = p->next;
        }
    }
}

// 从邻接矩阵创建邻接表
void createALGraph(AMGraph *M, ALGraph *G) {
    int i, j;
    ArcNode *p;
    G->vexnum = M->vexnum;
    G->arcnum = M->arcnum;
    for (i = 0; i < M->vexnum; i++) {
        G->vertices[i].data = M->vexs[i];
        G->vertices[i].first = NULL;
        for (j = M->vexnum - 1; j >= 0; j--) {
            if (M->arcs[i][j] == 1) {
                p = (ArcNode *)malloc(sizeof(ArcNode));
                p->adjvex = j;
                p->next = G->vertices[i].first;
                G->vertices[i].first = p;
            }
        }
    }
}

// 输出邻接表
void printALGraph(ALGraph G) {
    int i;
    ArcNode *p;
    for (i = 0; i < G.vexnum; i++) {
        printf("%c", G.vertices[i].data);
        p = G.vertices[i].first;
        while (p) {
            printf(" -> %c", G.vertices[p->adjvex].data);
            p = p->next;
        }
        printf("\n");
    }
}

// 输出邻接矩阵
void printAMGraph(AMGraph G) {
    int i, j;
    for (i = 0; i < G.vexnum; i++) {
        for (j = 0; j < G.vexnum; j++) {
            printf("%d ", G.arcs[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int i, j, k;
    char ch;
    ALGraph G;
    AMGraph M;
    ArcNode *p;
    printf("请输入顶点数和边数：\n");
    scanf("%d%d", &G.vexnum, &G.arcnum);
    getchar();
    printf("请依次输入每个顶点的信息：\n");
    for (i = 0; i < G.vexnum; i++) {
        scanf("%c", &G.vertices[i].data);
        G.vertices[i].first = NULL;
        getchar();
    }
    printf("请依次输入每条边的起点和终点：\n");
    for (k = 0; k < G.arcnum; k++) {
        scanf("%c%c", &ch, &ch);
        getchar();
        for (i = 0; i < G.vexnum; i++) {
            if (G.vertices[i].data == ch) {
                break;
            }
        }
        for (j = 0; j < G.vexnum; j++) {
            if (G.vertices[j].data == getchar()) {
                p = (ArcNode *)malloc(sizeof(ArcNode));
                p->adjvex = i;
                p->next = G.vertices[j].first;
                G.vertices[j].first = p;
                getchar();
                break;
            }
        }
    }
    printf("邻接表表示的图：\n");
    printALGraph(G);
    createAMGraph(&G, &M);
    printf("邻接矩阵表示的图：\n");
    printAMGraph(M);
    createALGraph(&M, &G);
    printf("再次输出邻接表表示的图：\n");
    printALGraph(G);
    return 0;
}

这段代码通过邻接表和邻接矩阵之间的转换，实现了无向图的建立和存储，并输出了图的C语言代码。