用C实现（1）输入无向图的顶点数、边数及各条边的顶点对，建立用邻接表表示的无向图。 （2）对图进行深度优先搜索和广度优先搜索遍历，并分别输出其遍历序列。

好的，我来回答你的问题。首先，让我们来看一下如何用邻接表表示无向图。

假设我们有n个顶点和m条边，我们可以定义一个结构体来表示每个顶点和它所连接的边。代码如下：

typedef struct EdgeNode {
    int adjvex; // 邻接点的下标
    struct EdgeNode* next; // 下一个邻接点的指针
} EdgeNode;

typedef struct VertexNode {
    int data; // 顶点的数据
    EdgeNode* firstedge; // 指向该顶点的第一个邻接点的指针
} VertexNode;

typedef struct {
    VertexNode adjlist[MAXVEX]; // 存储顶点的数组
    int numVertexes; // 顶点数
    int numEdges; // 边数
} GraphAdjList;

接下来，我们可以按照用户输入的顶点数、边数以及各条边的顶点对来建立无向图。代码如下：

void CreateGraph(GraphAdjList* G) {
    int i, j, k;
    EdgeNode* e;

    printf("请输入顶点数和边数：\n");
    scanf("%d %d", &G->numVertexes, &G->numEdges);

    // 读入顶点信息，存入顶点数组中
    for (i = 0; i < G->numVertexes; i++) {
        printf("请输入第%d个顶点的值：", i+1);
        scanf("%d", &G->adjlist[i].data);
        G->adjlist[i].firstedge = NULL;
    }

    // 读入边的信息，建立邻接表
    for (k = 0; k < G->numEdges; k++) {
        printf("请输入第%d条边的顶点对（vi, vj）的下标：", k+1);
        scanf("%d %d", &i, &j);

        // 添加一条边vi -> vj
        e = (EdgeNode*) malloc(sizeof(EdgeNode));
        e->adjvex = j;
        e->next = G->adjlist[i].firstedge;
        G->adjlist[i].firstedge = e;

        // 添加一条边vj -> vi
        e = (EdgeNode*) malloc(sizeof(EdgeNode));
        e->adjvex = i;
        e->next = G->adjlist[j].firstedge;
        G->adjlist[j].firstedge = e;
    }
}

现在我们已经建立好了无向图的邻接表表示。接下来，我们可以对图进行深度优先搜索和广度优先搜索遍历了。

深度优先搜索遍历的过程就是从某个顶点开始，一直往深处搜索，直到搜索不到为止，然后回溯到上一个节点再继续搜索。代码如下：

int visited[MAXVEX]; // 标记顶点是否已经被访问过

void DFS(GraphAdjList* G, int i) {
    EdgeNode* p;

    visited[i] = 1;
    printf("%d ", G->adjlist[i].data);

    p = G->adjlist[i].firstedge;
    while (p != NULL) {
        if (!visited[p->adjvex]) {
            DFS(G, p->adjvex);
        }
        p = p->next;
    }
}

void DFSTraverse(GraphAdjList* G) {
    int i;
    for (i = 0; i < G->numVertexes; i++) {
        visited[i] = 0;
    }

    for (i = 0; i < G->numVertexes; i++) {
        if (!visited[i]) {
            DFS(G, i);
        }
    }
}

广度优先搜索遍历的过程就是从某个顶点开始，依次访问它的邻接点，然后再依次访问邻接点的邻接点，直到没有未访问的节点为止。代码如下：

void BFSTraverse(GraphAdjList* G) {
    int i;
    EdgeNode* p;
    Queue Q;

    for (i = 0; i < G->numVertexes; i++) {
        visited[i] = 0;
    }

    InitQueue(&Q);
    for (i = 0; i < G->numVertexes; i++) {
        if (!visited[i]) {
            visited[i] = 1;
            printf("%d ", G->adjlist[i].data);
            EnQueue(&Q, i);

            while (!QueueEmpty(Q)) {
                DeQueue(&Q, &i);
                p = G->adjlist[i].firstedge;
                while (p != NULL) {
                    if (!visited[p->adjvex]) {
                        visited[p->adjvex] = 1;
                        printf("%d ", G->adjlist[p->adjvex].data);
                        EnQueue(&Q, p->adjvex);
                    }
                    p = p->next;
                }
            }
        }
    }
}

最后，我们可以在主函数中调用CreateGraph、DFSTraverse和BFSTraverse来测试我们的代码。完整代码如下所示：