/*第三关 完成图的广度遍历（周游），可根据需要添加自定义函数 */ void BFS_list(GraphList *G) { }

以下是图的广度优先搜索（BFS）算法实现的代码：

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

#define MAX_VERTEX_NUM 100

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

// 顶点信息
typedef struct VertexNode {
    int data;               // 顶点信息
    ArcNode *firstarc;      // 指向第一个邻接点
} VertexNode;

// 邻接表
typedef struct GraphList {
    VertexNode vertex[MAX_VERTEX_NUM];  // 存放顶点信息
    int vexnum;                         // 顶点数目
    int arcnum;                         // 边数目
} GraphList;

// 初始化邻接表并输出图的邻接表
GraphList *initGraphList() {
    GraphList *G = (GraphList *)malloc(sizeof(GraphList));
    if (!G) {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    printf("Please enter graph type, number of vertices, and number of edges: ");
    scanf("%*s%d%d", &G->vexnum, &G->arcnum);

    // 初始化邻接表
    for (int i = 0; i < G->vexnum; i++) {
        printf("Please enter the information of vertex %d: ", i + 1);
        scanf("%d", &G->vertex[i].data);
        G->vertex[i].firstarc = NULL;
    }

    // 读入边信息，建立邻接表
    for (int i = 0; i < G->arcnum; i++) {
        int v1, v2;
        printf("Please enter the two vertices of edge %d: ", i + 1);
        scanf("%d%d", &v1, &v2);

        // 添加边 v1 -> v2
        ArcNode *arc1 = (ArcNode *)malloc(sizeof(ArcNode));
        arc1->adjvex = v2 - 1;
        arc1->next = G->vertex[v1 - 1].firstarc;
        G->vertex[v1 - 1].firstarc = arc1;

        // 添加边 v2 -> v1
        ArcNode *arc2 = (ArcNode *)malloc(sizeof(ArcNode));
        arc2->adjvex = v1 - 1;
        arc2->next = G->vertex[v2 - 1].firstarc;
        G->vertex[v2 - 1].firstarc = arc2;
    }

    // 输出邻接表
    printf("Adjacency list of the graph:\n");
    for (int i = 0; i < G->vexnum; i++) {
        printf("%d: ", G->vertex[i].data);
        ArcNode *arc = G->vertex[i].firstarc;
        while (arc) {
            printf("%d ", G->vertex[arc->adjvex].data);
            arc = arc->next;
        }
        printf("\n");
    }

    return G;
}

// 输出邻接表
void printGraphList(GraphList *G) {
    printf("Adjacency list of the graph:\n");
    for (int i = 0; i < G->vexnum; i++) {
        printf("%d: ", G->vertex[i].data);
        ArcNode *arc = G->vertex[i].firstarc;
        while (arc) {
            printf("%d ", G->vertex[arc->adjvex].data);
            arc = arc->next;
        }
        printf("\n");
    }
}

// 广度优先搜索
void BFS_list(GraphList *G) {
    int visited[MAX_VERTEX_NUM] = {0};  // 记录每个节点是否被访问过
    int queue[MAX_VERTEX_NUM] = {0};    // 队列
    int front = 0, rear = 0;            // 队首和队尾指针

    // 对于每个未访问的节点，进行广度优先搜索
    for (int i = 0; i < G->vexnum; i++) {
        if (!visited[i]) {
            visited[i] = 1;             // 标记为已访问
            printf("%d ", G->vertex[i].data);
            queue[rear++] = i;          // 将节点加入队列

            // 遍历队列中的节点
            while (front < rear) {
                int v = queue[front++]; // 取出队首节点
                ArcNode *arc = G->vertex[v].firstarc;
                while (arc) {
                    if (!visited[arc->adjvex]) {
                        visited[arc->adjvex] = 1;   // 标记为已访问
                        printf("%d ", G->vertex[arc->adjvex].data);
                        queue[rear++] = arc->adjvex; // 将节点加入队列
                    }
                    arc = arc->next;
                }
            }
        }
    }
}

注意事项：

1. 在 `BFS_list` 函数中，使用一个 `visited` 数组记录每个节点是否被访问过，使用一个 `queue` 数组作为队列，`front` 和 `rear` 分别指向队首和队尾。
2. 遍历邻接表时，使用 `ArcNode *arc = G->vertex[v].firstarc` 访问节点 `v` 的邻接点，其中 `G->vertex[v].firstarc` 是节点 `v` 第一个邻接点的指针。
3. 在遍历队列中的节点时，将其邻接点加入队列，并在 `visited` 数组中标记为已访问。