判断上图是否含有环，若没有则输出其拓扑序列。（C语言）

这是一个经典的拓扑排序问题。可以使用邻接表来表示图，然后使用队列实现拓扑排序。

以下是一个示例代码实现：

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

#define MAX_VERTEX_NUM 100 // 最大顶点数

typedef struct ArcNode {
    int adjvex; // 邻接顶点
    struct ArcNode* nextarc; // 指向下一个邻接点的指针
} ArcNode;

typedef struct VertexNode {
    int data; // 顶点数据
    ArcNode* firstarc; // 指向第一条依附该顶点的弧的指针
} VertexNode;

typedef struct {
    VertexNode vertex[MAX_VERTEX_NUM]; // 顶点数组
    int vexnum, arcnum; // 顶点数和弧数
} Graph;

// 初始化图
void initGraph(Graph* G, int n) {
    G->vexnum = n;
    G->arcnum = 0;
    for (int i = 0; i < n; i++) {
        G->vertex[i].data = i;
        G->vertex[i].firstarc = NULL;
    }
}

// 添加一条边
void addEdge(Graph* G, int v, int w) {
    ArcNode* arc = (ArcNode*)malloc(sizeof(ArcNode));
    arc->adjvex = w;
    arc->nextarc = G->vertex[v].firstarc;
    G->vertex[v].firstarc = arc;
    G->arcnum++;
}

// 拓扑排序
void topologicalSort(Graph* G) {
    // 入度数组
    int* indegree = (int*)calloc(G->vexnum, sizeof(int));
    for (int i = 0; i < G->vexnum; i++) {
        for (ArcNode* arc = G->vertex[i].firstarc; arc != NULL; arc = arc->nextarc) {
            indegree[arc->adjvex]++;
        }
    }

    // 将入度为0的顶点加入队列
    int* queue = (int*)malloc(G->vexnum * sizeof(int));
    int front = 0, rear = 0;
    for (int i = 0; i < G->vexnum; i++) {
        if (indegree[i] == 0) {
            queue[rear++] = i;
        }
    }

    // 拓扑排序
    while (front != rear) {
        int v = queue[front++];
        printf("%d ", v);
        for (ArcNode* arc = G->vertex[v].firstarc; arc != NULL; arc = arc->nextarc) {
            indegree[arc->adjvex]--;
            if (indegree[arc->adjvex] == 0) {
                queue[rear++] = arc->adjvex;
            }
        }
    }

    printf("\n");

    free(indegree);
    free(queue);
}

int main() {
    Graph G;
    initGraph(&G, 6);
    addEdge(&G, 0, 1);
    addEdge(&G, 0, 2);
    addEdge(&G, 1, 3);
    addEdge(&G, 2, 3);
    addEdge(&G, 2, 4);
    addEdge(&G, 3, 5);
    addEdge(&G, 4, 5);

    topologicalSort(&G);

    return 0;
}

以上代码实现的拓扑排序算法的时间复杂度为 $O(|V|+|E|)$，其中 $|V|$ 表示顶点数，$|E|$ 表示边数。