实现图的存储，输出存储结构示意图； 输出对建立的图进行深度优先搜索和广度优先搜索所得的遍历序列（C语言，邻接多重表）

邻接多重表是一种常用的图的存储结构，其基本思路是将每个边所关联的两个顶点都看作一个个体，然后将这些个体存储在一个链表中，并用指针链接它们。邻接多重表适用于无向图和有向图，并且可以很方便地实现深度优先搜索和广度优先搜索。

下面是邻接多重表的存储结构示意图：

typedef struct node
{
    int ivex; // 该边所关联的一个顶点的编号
    int jvex; // 该边所关联的另一个顶点的编号
    struct node *ilink; // 指向下一条与i关联的边的指针
    struct node *jlink; // 指向下一条与j关联的边的指针
}EdgeNode;

typedef struct vnode
{
    char data; // 顶点的数据域
    EdgeNode *firstedge; // 指向第一条与该顶点关联的边的指针
}VertexNode;

typedef struct
{
    VertexNode adjmulist[MAXVEX]; // 存储图中所有顶点的邻接链表
    int vexnum, edgenum; // 存储图的顶点数和边数
}AMLGraph;

接下来是使用邻接多重表进行深度优先搜索和广度优先搜索的代码实现：

// 初始化图
void InitGraph(AMLGraph *G)
{
    // 读入顶点数和边数
    scanf("%d%d", &G->vexnum, &G->edgenum);
    getchar(); // 消耗掉换行符

    // 读入每个顶点的数据
    for (int i = 0; i < G->vexnum; i++)
    {
        scanf("%c", &G->adjmulist[i].data);
        G->adjmulist[i].firstedge = NULL;
        getchar(); // 消耗掉换行符
    }

    // 读入每条边的信息
    for (int i = 0; i < G->edgenum; i++)
    {
        int v1, v2;
        scanf("%d%d", &v1, &v2);
        getchar(); // 消耗掉换行符

        EdgeNode *e = (EdgeNode*)malloc(sizeof(EdgeNode));
        e->ivex = v1;
        e->jvex = v2;
        e->ilink = G->adjmulist[v1].firstedge;
        e->jlink = G->adjmulist[v2].firstedge;
        G->adjmulist[v1].firstedge = G->adjmulist[v2].firstedge = e;
    }
}

// 深度优先搜索
void DFS(AMLGraph *G, int v, bool visited[])
{
    visited[v] = true;
    printf("%c ", G->adjmulist[v].data);

    EdgeNode *e = G->adjmulist[v].firstedge;
    while (e != NULL)
    {
        int w;
        if (e->ivex == v) w = e->jvex;
        else w = e->ivex;

        if (!visited[w])
        {
            DFS(G, w, visited);
        }

        e = (e->ivex == v ? e->ilink : e->jlink);
    }
}

// 广度优先搜索
void BFS(AMLGraph *G, int v, bool visited[])
{
    visited[v] = true;
    printf("%c ", G->adjmulist[v].data);

    queue<int> q;
    q.push(v);

    while (!q.empty())
    {
        int u = q.front();
        q.pop();

        EdgeNode *e = G->adjmulist[u].firstedge;
        while (e != NULL)
        {
            int w;
            if (e->ivex == u) w = e->jvex;
            else w = e->ivex;

            if (!visited[w])
            {
                visited[w] = true;
                printf("%c ", G->adjmulist[w].data);
                q.push(w);
            }

            e = (e->ivex == u ? e->ilink : e->jlink);
        }
    }
}

int main()
{
    AMLGraph G;
    InitGraph(&G);

    // 深度优先搜索
    bool visited[MAXVEX] = {false};
    for (int i = 0; i < G.vexnum; i++)
    {
        if (!visited[i])
        {
            DFS(&G, i, visited);
        }
    }
    printf("\n");

    // 广度优先搜索
    memset(visited, false, sizeof(visited));
    for (int i = 0; i < G.vexnum; i++)
    {
        if (!visited[i])
        {
            BFS(&G, i, visited);
        }
    }
    printf("\n");

    return 0;
}