用C语言在有向图的邻接表存储结构基础上对图进行广度优先搜索遍历并输出顶点序列并举例

好的，我来回答你的问题。

对于有向图的广度优先搜索遍历，我们需要借助队列来实现。具体步骤如下：

1. 初始化队列，并将起点入队。
2. 取出队头元素，并将其未访问过的邻接点入队。
3. 将已经访问过的顶点标记为已访问。
4. 重复步骤2和步骤3，直到队列为空。

以下是基于邻接表存储结构的C语言实现代码：

#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 {
    VertexNode vexs[MAX_VERTEX_NUM];    // 顶点数组
    int vexnum;                         // 顶点数
    int arcnum;                         // 弧数
}ALGraph;

// 初始化邻接表
void InitGraph(ALGraph *G) {
    int i;
    G->vexnum = 0;
    G->arcnum = 0;
    for(i = 0; i < MAX_VERTEX_NUM; i++) {
        G->vexs[i].firstarc = NULL;
    }
}

// 添加一条有向边
void AddArc(ALGraph *G, int v, int w) {
    ArcNode *arc = (ArcNode*)malloc(sizeof(ArcNode));
    arc->adjvex = w;
    arc->next = G->vexs[v].firstarc;
    G->vexs[v].firstarc = arc;
    G->arcnum++;
}

// 广度优先搜索遍历
void BFS(ALGraph *G, int v, int visited[]) {
    int queue[MAX_VERTEX_NUM];      // 定义队列
    int front = 0, rear = 0;        // 队列的头尾指针
    int i, w;

    visited[v] = 1;                 // 标记起点已访问
    printf("%d ", G->vexs[v].data); // 输出起点

    queue[rear++] = v;              // 起点入队
    while(front < rear) {           // 队列不为空时
        i = queue[front++];         // 取出队头元素
        ArcNode *p = G->vexs[i].firstarc;
        while(p != NULL) {          // 遍历i的邻接点
            w = p->adjvex;
            if(!visited[w]) {       // 如果未访问过，则入队
                visited[w] = 1;     // 标记已访问
                printf("%d ", G->vexs[w].data);
                queue[rear++] = w;
            }
            p = p->next;
        }
    }
}

int main() {
    ALGraph G;
    int visited[MAX_VERTEX_NUM];    // 标记已访问的顶点
    int i;

    InitGraph(&G);

    // 添加顶点
    for(i = 1; i <= 6; i++) {
        G.vexs[i].data = i;
        G.vexnum++;
    }

    // 添加边
    AddArc(&G, 1, 2);
    AddArc(&G, 1, 3);
    AddArc(&G, 2, 4);
    AddArc(&G, 2, 5);
    AddArc(&G, 3, 5);
    AddArc(&G, 4, 6);
    AddArc(&G, 5, 4);
    AddArc(&G, 5, 6);

    // 初始化visited数组
    for(i = 1; i <= G.vexnum; i++) {
        visited[i] = 0;
    }

    // 从顶点1开始进行广度优先搜索遍历
    BFS(&G, 1, visited);

    return 0;
}

以上代码实现了对如下有向图的广度优先搜索遍历：

  1 --> 2 --> 4 --> 6
  |     |
  v     v
  3 --> 5

输出结果为：`1 2 3 4 5 6`

希望这个例子能够帮到你。