c语言以邻接表存储一个图并输出它的一个拓扑排序

### 回答1：
C语言可以使用邻接表来存储一个图，并且可以通过拓扑排序算法来输出图的拓扑排序结果。

首先，我们需要定义一个结构体来表示图的顶点和边。结构体包含一个顶点的标识符和一个指向链表的指针，用于存储与该顶点相邻的顶点。

// 定义图的顶点结构体
struct Vertex {
    int id;  // 顶点的标识符
    struct Vertex* next;  // 指向相邻顶点的链表
};

接下来，我们可以使用数组来创建一个顶点列表，每个数组元素都是一个指向顶点结构体的指针。

struct Vertex* graph[100];

然后，我们可以编写一个函数来将边添加到图中。该函数将接受两个顶点的标识符作为参数，并将边添加到顶点的链表中。

// 向图中添加边
void addEdge(int from, int to) {
    struct Vertex* vertex = (struct Vertex*) malloc(sizeof(struct Vertex));
    vertex->id = to;
    vertex->next = graph[from];
    graph[from] = vertex;
}

接下来，我们需要编写一个拓扑排序函数来输出图的拓扑排序结果。拓扑排序使用深度优先搜索算法来访问所有顶点，并利用栈来记录访问的顶点。

// 深度优先搜索
void dfs(int v, int visited[], struct Vertex* stack[], int* top) {
    visited[v] = 1;
    struct Vertex* vertex = graph[v];
    while (vertex != NULL) {
        int id = vertex->id;
        if (!visited[id]) {
            dfs(id, visited, stack, top);
        }
        vertex = vertex->next;
    }
    stack[*top] = graph[v];
    (*top)++;
}

// 拓扑排序
void topologicalSort(int numVertices) {
    int visited[100] = {0};  // 记录顶点是否已访问
    struct Vertex* stack[100];
    int top = 0;

    for (int i = 0; i < numVertices; i++) {
        if (!visited[i]) {
            dfs(i, visited, stack, &top);
        }
    }

    printf("拓扑排序结果：");
    for (int i = top - 1; i >= 0; i--) {
        printf("%d ", stack[i]->id);
    }
    printf("\n");
}

最后，我们可以在主函数中构建图并调用拓扑排序函数来输出拓扑排序结果。

int main() {
    // 构建图
    addEdge(0, 1);
    addEdge(0, 2);
    addEdge(1, 3);
    addEdge(2, 3);
    addEdge(2, 4);
    addEdge(3, 4);

    // 输出拓扑排序
    topologicalSort(5);

    return 0;
}

以上代码将输出拓扑排序结果：0 2 1 3 4。这是图的一种拓扑排序方式。

### 回答2：
C语言可以通过邻接表来存储一个图。邻接表是一种数据结构，用来表示图中的顶点和边的关系。在邻接表中，图的顶点被表示为一个数组，每个顶点都有一个链表，链表中存储了与该顶点相邻的其他顶点。

实现一个图的拓扑排序，可以利用邻接表和深度优先搜索算法。

首先，定义一个结构体来表示图的顶点和边：

typedef struct Node {
    int val;
    struct Node* next;
} Node;

typedef struct Graph {
    int numVertices;
    Node** adjLists;
} Graph;

接下来，我们需要实现图的初始化和添加边的函数：

Graph* createGraph(int numVertices)
{
    Graph* graph = (Graph*)malloc(sizeof(Graph));
    graph->numVertices = numVertices;

    graph->adjLists = (Node**)malloc(numVertices * sizeof(Node*));

    for (int i = 0; i < numVertices; i++) {
        graph->adjLists[i] = NULL;
    }

    return graph;
}

void addEdge(Graph* graph, int src, int dest)
{
    // 添加一条边从顶点src到dest
    Node* newNode = createNode(dest);
    newNode->next = graph->adjLists[src];
    graph->adjLists[src] = newNode;
}

接下来，我们需要实现拓扑排序算法。拓扑排序通过深度优先搜索来遍历图的顶点，并按照遍历的顺序输出拓扑排序结果。具体实现如下：

void topologicalSortUtil(int v, bool visited[], Graph* graph, Stack* stack)
{
    // 将当前顶点标记为已访问
    visited[v] = true;

    Node* adjList = graph->adjLists[v];

    while (adjList != NULL) {
        int adjVertex = adjList->val;

        if (!visited[adjVertex]) {
            topologicalSortUtil(adjVertex, visited, graph, stack);
        }

        adjList = adjList->next;
    }

    // 将当前顶点推入栈中
    push(stack, v);
}

void topologicalSort(Graph* graph)
{
    Stack* stack = createStack();
    bool visited[graph->numVertices];

    for (int i = 0; i < graph->numVertices; i++) {
        visited[i] = false;
    }

    for (int i = 0; i < graph->numVertices; i++) {
        if (!visited[i]) {
            topologicalSortUtil(i, visited, graph, stack);
        }
    }

    // 输出拓扑排序结果
    while (!isEmpty(stack)) {
        printf("%d ", pop(stack));
    }

    free(stack);
}

利用上述的代码，我们就可以通过邻接表来存储一个图，并输出它的一个拓扑排序了。

### 回答3：
拓扑排序是对有向无环图（DAG）进行排序的一种算法，用于表示任务的依赖关系或事件发生的顺序。

在C语言中，我们可以使用邻接表来存储一个图，并通过拓扑排序算法输出其拓扑排序的结果。

首先，我们需要定义一个结构体来表示图中的每个节点：

struct Node {
    int value;
    struct Node* next;
};

然后，我们可以创建一个邻接表数组，其中每个索引位置对应一个节点：

struct Node* adjacencyList[MAX_SIZE];

接下来，我们可以编写一个函数来添加边到图中：

void addEdge(int src, int dest) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->value = dest;
    newNode->next = adjacencyList[src];
    adjacencyList[src] = newNode;
}

接着，我们可以编写一个DFS函数来实现拓扑排序：

void dfs(int vertex, bool visited[], struct Node* stack) {
    visited[vertex] = true;
    struct Node* temp = adjacencyList[vertex];

    while (temp != NULL) {
        int adjVertex = temp->value;

        if (!visited[adjVertex]) {
            dfs(adjVertex, visited, stack);
        }

        temp = temp->next;
    }

    struct Node* newVertex = (struct Node*)malloc(sizeof(struct Node));
    newVertex->value = vertex;
    newVertex->next = stack;
    stack = newVertex;
}

最后，我们可以编写一个函数来调用DFS并输出拓扑排序的结果：

void topologicalSort() {
    bool visited[MAX_SIZE];
    struct Node* stack = NULL;

    for (int i = 0; i < MAX_SIZE; i++) {
        visited[i] = false;
    }

    for (int i = 0; i < MAX_SIZE; i++) {
        if (!visited[i]) {
            dfs(i, visited, stack);
        }
    }

    while (stack != NULL) {
        printf("%d ", stack->value);
        stack = stack->next;
    }
}

通过以上步骤，我们可以用C语言实现一个以邻接表存储的图，并输出其拓扑排序的结果。