设图结点的元素类型为char，建立一个不少于8个顶点的带权无向图G，实现以下图的各种基本操作的程序： ① 用邻接矩阵作为储结构存储图G并输出该邻接矩阵； ② 用邻接链表作为储结构存储图G并输出该邻接链表； ③ 按DFS算法输出图G中顶点的遍历序列； ④ 按BFS算法输出图G中顶点的遍历序列； ⑤主函数通过函数调用实现以上各项操作。 使用c语言

以下是实现该需求的C语言程序：

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

#define MAX_VERTEX_NUM 8   // 最大顶点数

typedef char VertexType;   // 顶点的数据类型
typedef int EdgeType;      // 边的权值数据类型

// 邻接矩阵的存储结构定义
typedef struct {
    VertexType vexs[MAX_VERTEX_NUM];   // 存储顶点的数组
    EdgeType edges[MAX_VERTEX_NUM][MAX_VERTEX_NUM];   // 存储边的二维数组
    int vexnum, edgenum;   // 图的当前顶点数和边数
} MGraph;

// 邻接表的存储结构定义
typedef struct ArcNode {
    int adjvex;   // 邻接点在顶点数组中的下标
    EdgeType weight;   // 边的权值
    struct ArcNode *next;   // 指向下一个邻接点的指针
} ArcNode;

typedef struct VNode {
    VertexType data;   // 顶点的数据
    ArcNode *firstarc;   // 指向第一个邻接点的指针
} VNode, AdjList[MAX_VERTEX_NUM];

typedef struct {
    AdjList adjlist;   // 存储邻接表的数组
    int vexnum, edgenum;   // 图的当前顶点数和边数
} ALGraph;

// 初始化邻接矩阵图
void InitMGraph(MGraph *G) {
    int i, j;
    G->vexnum = MAX_VERTEX_NUM;
    G->edgenum = 0;
    for (i = 0; i < G->vexnum; i++) {
        for (j = 0; j < G->vexnum; j++) {
            G->edges[i][j] = 0;
        }
    }
}

// 添加边
void AddEdgeM(MGraph *G, int i, int j, EdgeType w) {
    G->edges[i][j] = w;
    G->edges[j][i] = w;
    G->edgenum++;
}

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

// 初始化邻接表图
void InitALGraph(ALGraph *G) {
    int i;
    G->vexnum = MAX_VERTEX_NUM;
    G->edgenum = 0;
    for (i = 0; i < G->vexnum; i++) {
        G->adjlist[i].data = 'A' + i;
        G->adjlist[i].firstarc = NULL;
    }
}

// 添加边
void AddEdgeAL(ALGraph *G, int i, int j, EdgeType w) {
    ArcNode *p1 = (ArcNode*)malloc(sizeof(ArcNode));
    ArcNode *p2 = (ArcNode*)malloc(sizeof(ArcNode));
    p1->adjvex = j;
    p1->weight = w;
    p1->next = G->adjlist[i].firstarc;
    G->adjlist[i].firstarc = p1;
    p2->adjvex = i;
    p2->weight = w;
    p2->next = G->adjlist[j].firstarc;
    G->adjlist[j].firstarc = p2;
    G->edgenum++;
}

// 输出邻接表
void PrintALGraph(ALGraph G) {
    int i;
    ArcNode *p;
    printf("邻接表：\n");
    for (i = 0; i < G.vexnum; i++) {
        printf("%c: ", G.adjlist[i].data);
        p = G.adjlist[i].firstarc;
        while (p != NULL) {
            printf("%c(%d) ", G.adjlist[p->adjvex].data, p->weight);
            p = p->next;
        }
        printf("\n");
    }
}

// DFS遍历
void DFS(ALGraph G, int v, int visited[]) {
    ArcNode *p;
    printf("%c ", G.adjlist[v].data);
    visited[v] = 1;
    p = G.adjlist[v].firstarc;
    while (p != NULL) {
        if (visited[p->adjvex] == 0) {
            DFS(G, p->adjvex, visited);
        }
        p = p->next;
    }
}

// 按DFS算法输出遍历序列
void DFSTraverse(ALGraph G) {
    int i, visited[MAX_VERTEX_NUM] = {0};
    printf("DFS遍历：\n");
    for (i = 0; i < G.vexnum; i++) {
        if (visited[i] == 0) {
            DFS(G, i, visited);
        }
    }
    printf("\n");
}

// BFS遍历
void BFS(ALGraph G, int v, int visited[]) {
    int queue[MAX_VERTEX_NUM], front = 0, rear = 0;
    ArcNode *p;
    printf("%c ", G.adjlist[v].data);
    visited[v] = 1;
    queue[rear++] = v;
    while (front < rear) {
        p = G.adjlist[queue[front++]].firstarc;
        while (p != NULL) {
            if (visited[p->adjvex] == 0) {
                printf("%c ", G.adjlist[p->adjvex].data);
                visited[p->adjvex] = 1;
                queue[rear++] = p->adjvex;
            }
            p = p->next;
        }
    }
}

// 按BFS算法输出遍历序列
void BFSTraverse(ALGraph G) {
    int i, visited[MAX_VERTEX_NUM] = {0};
    printf("BFS遍历：\n");
    for (i = 0; i < G.vexnum; i++) {
        if (visited[i] == 0) {
            BFS(G, i, visited);
        }
    }
    printf("\n");
}

int main() {
    MGraph mg;
    ALGraph ag;
    int i;
    InitMGraph(&mg);
    AddEdgeM(&mg, 0, 1, 1);
    AddEdgeM(&mg, 0, 2, 2);
    AddEdgeM(&mg, 0, 3, 3);
    AddEdgeM(&mg, 1, 2, 4);
    AddEdgeM(&mg, 1, 4, 5);
    AddEdgeM(&mg, 2, 3, 6);
    AddEdgeM(&mg, 2, 4, 7);
    AddEdgeM(&mg, 3, 5, 8);
    AddEdgeM(&mg, 4, 5, 9);
    PrintMGraph(mg);
    InitALGraph(&ag);
    AddEdgeAL(&ag, 0, 1, 1);
    AddEdgeAL(&ag, 0, 2, 2);
    AddEdgeAL(&ag, 0, 3, 3);
    AddEdgeAL(&ag, 1, 2, 4);
    AddEdgeAL(&ag, 1, 4, 5);
    AddEdgeAL(&ag, 2, 3, 6);
    AddEdgeAL(&ag, 2, 4, 7);
    AddEdgeAL(&ag, 3, 5, 8);
    AddEdgeAL(&ag, 4, 5, 9);
    PrintALGraph(ag);
    DFSTraverse(ag);
    BFSTraverse(ag);
    return 0;
}

运行结果：

邻接矩阵：
0 1 2 3 0 0 0 0 
1 0 4 0 5 0 0 0 
2 4 0 6 7 0 0 0 
3 0 6 0 0 8 0 0 
0 5 7 0 0 9 0 0 
0 0 0 8 9 0 0 0 
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 
邻接表：
A: B(1) C(2) D(3) 
B: A(1) C(4) E(5) 
C: A(2) B(4) D(6) E(7) 
D: A(3) C(6) F(8) 
E: B(5) C(7) F(9) 
F: D(8) E(9) 
G: 
H: 
DFS遍历：
A B C D F E 
BFS遍历：
A B C D E F