在C语言的环境下，输入一组顶点，建立无向图的邻接矩阵。 输入一组顶点，建立有向图的邻接表。 以邻接矩阵为存储结构，对无向图分别进行DFS（深度优先遍历）和BFS（广度优先遍历）。请将完整代码展示给我

好的，以下是完整代码，其中无向图邻接矩阵和有向图邻接表的建立可以通过用户输入完成，DFS和BFS遍历分别封装成函数dfs和bfs：

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

#define MAX_VERTEX_NUM 100 // 最大顶点数

/* 邻接矩阵结构体 */
typedef struct {
    int vexs[MAX_VERTEX_NUM]; // 顶点数组
    int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 邻接矩阵
    int vexnum, arcnum; // 顶点数和边数
} MGraph;

/* 邻接表结构体 */
typedef struct ArcNode {
    int adjvex; // 目标顶点编号
    struct ArcNode *next; // 指向下一个节点的指针
} ArcNode;

typedef struct {
    int data; // 顶点数据
    ArcNode *firstarc; // 指向第一个节点的指针
} VNode;

typedef struct {
    VNode adjlist[MAX_VERTEX_NUM]; // 邻接表数组
    int vexnum, arcnum; // 顶点数和边数
} ALGraph;

/* 初始化无向图邻接矩阵 */
void InitMGraph(MGraph *G) {
    int i, j, k, w;
    printf("请输入顶点数和边数：\n");
    scanf("%d %d", &G->vexnum, &G->arcnum);
    printf("请输入顶点信息：\n");
    for (i = 0; i < G->vexnum; i++) {
        scanf("%d", &G->vexs[i]);
    }
    for (i = 0; i < G->vexnum; i++) {
        for (j = 0; j < G->vexnum; j++) {
            G->arcs[i][j] = 0; // 初始化为0
        }
    }
    printf("请输入每条边的两个顶点和权值：\n");
    for (k = 0; k < G->arcnum; k++) {
        scanf("%d %d %d", &i, &j, &w);
        G->arcs[i][j] = w;
        G->arcs[j][i] = w; // 无向图，需要对称赋值
    }
}

/* 初始化有向图邻接表 */
void InitALGraph(ALGraph *G) {
    int i, j, k, w;
    ArcNode *p;
    printf("请输入顶点数和边数：\n");
    scanf("%d %d", &G->vexnum, &G->arcnum);
    printf("请输入顶点信息：\n");
    for (i = 0; i < G->vexnum; i++) {
        scanf("%d", &G->adjlist[i].data);
        G->adjlist[i].firstarc = NULL; // 初始化指针为空
    }
    printf("请输入每条边的起点、终点和权值：\n");
    for (k = 0; k < G->arcnum; k++) {
        scanf("%d %d %d", &i, &j, &w);
        p = (ArcNode *)malloc(sizeof(ArcNode));
        p->adjvex = j; // 目标顶点编号
        p->next = G->adjlist[i].firstarc; // 头插法
        G->adjlist[i].firstarc = p;
    }
}

/* DFS遍历邻接矩阵 */
void dfs(MGraph G, int v, int visited[]) {
    int i;
    visited[v] = 1; // 标记已访问
    printf("%d ", G.vexs[v]); // 输出顶点
    for (i = 0; i < G.vexnum; i++) {
        if (G.arcs[v][i] && !visited[i]) {
            dfs(G, i, visited); // 递归访问邻接点
        }
    }
}

/* BFS遍历邻接矩阵 */
void bfs(MGraph G, int v, int visited[]) {
    int i, j, queue[MAX_VERTEX_NUM], front = 0, rear = 0; // 队列
    visited[v] = 1; // 标记已访问
    printf("%d ", G.vexs[v]); // 输出顶点
    queue[rear++] = v; // 入队
    while (front != rear) {
        i = queue[front++]; // 出队
        for (j = 0; j < G.vexnum; j++) {
            if (G.arcs[i][j] && !visited[j]) {
                visited[j] = 1; // 标记已访问
                printf("%d ", G.vexs[j]); // 输出顶点
                queue[rear++] = j; // 入队
            }
        }
    }
}

int main() {
    int i, visited[MAX_VERTEX_NUM];
    MGraph G1;
    ALGraph G2;
    InitMGraph(&G1);
    InitALGraph(&G2);
    printf("无向图邻接矩阵DFS遍历结果：\n");
    for (i = 0; i < G1.vexnum; i++) {
        visited[i] = 0; // 初始化标记数组
    }
    for (i = 0; i < G1.vexnum; i++) {
        if (!visited[i]) {
            dfs(G1, i, visited);
        }
    }
    printf("\n无向图邻接矩阵BFS遍历结果：\n");
    for (i = 0; i < G1.vexnum; i++) {
        visited[i] = 0; // 初始化标记数组
    }
    for (i = 0; i < G1.vexnum; i++) {
        if (!visited[i]) {
            bfs(G1, i, visited);
        }
    }
    printf("\n有向图邻接表DFS遍历结果：\n");
    for (i = 0; i < G2.vexnum; i++) {
        visited[i] = 0; // 初始化标记数组
    }
    for (i = 0; i < G2.vexnum; i++) {
        if (!visited[i]) {
            dfs(G2, i, visited);
        }
    }
    printf("\n有向图邻接表BFS遍历结果：\n");
    for (i = 0; i < G2.vexnum; i++) {
        visited[i] = 0; // 初始化标记数组
    }
    for (i = 0; i < G2.vexnum; i++) {
        if (!visited[i]) {
            bfs(G2, i, visited);
        }
    }
    printf("\n");
    return 0;
}

需要注意的是，邻接矩阵和邻接表的建立需要用户输入，需要按照题目要求输入顶点数、边数以及每条边的起点、终点和权值。