给出一个关键路径的案例例题并运用数据结构知识编写一个C语言代码。

案例例题：假设有一个工程项目，包括以下几个任务及其所需的时间：任务A：3天任务B：4天任务C：2天任务D：5天任务E：6天

任务之间存在以下的依赖关系：

任务A必须在任务B完成后才能开始；
任务B和任务C可以并行进行；
任务C必须在任务D完成后才能开始；
任务D必须在任务E完成后才能开始。

请编写一个C语言代码，计算出该工程项目的关键路径。

代码如下：

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

#define MAX_TASKS 5

// 定义任务结构体
typedef struct {
    char name;
    int duration;
    int early_start;
    int early_finish;
    int late_start;
    int late_finish;
    int slack;
} Task;

// 初始化任务信息
void initializeTasks(Task tasks[]) {
    tasks[0] = (Task) { 'A', 3, 0, 0, 0, 0, 0 };
    tasks[1] = (Task) { 'B', 4, 0, 0, 0, 0, 0 };
    tasks[2] = (Task) { 'C', 2, 0, 0, 0, 0, 0 };
    tasks[3] = (Task) { 'D', 5, 0, 0, 0, 0, 0 };
    tasks[4] = (Task) { 'E', 6, 0, 0, 0, 0, 0 };
}

// 计算任务的最早开始时间和最早完成时间
void calculateEarlyTimes(Task tasks[]) {
    tasks[0].early_start = 0;
    tasks[0].early_finish = tasks[0].duration;

    for (int i = 1; i < MAX_TASKS; i++) {
        int max_early_finish = 0;
        for (int j = 0; j < i; j++) {
            if (tasks[j].early_finish > max_early_finish) {
                max_early_finish = tasks[j].early_finish;
            }
        }
        tasks[i].early_start = max_early_finish;
        tasks[i].early_finish = max_early_finish + tasks[i].duration;
    }
}

// 计算任务的最晚开始时间和最晚完成时间
void calculateLateTimes(Task tasks[]) {
    tasks[MAX_TASKS - 1].late_finish = tasks[MAX_TASKS - 1].early_finish;
    tasks[MAX_TASKS - 1].late_start = tasks[MAX_TASKS - 1].late_finish - tasks[MAX_TASKS - 1].duration;

    for (int i = MAX_TASKS - 2; i >= 0; i--) {
        int min_late_start = tasks[MAX_TASKS - 1].late_start;
        for (int j = MAX_TASKS - 1; j > i; j--) {
            if (tasks[j].late_start < min_late_start) {
                min_late_start = tasks[j].late_start;
            }
        }
        tasks[i].late_finish = min_late_start;
        tasks[i].late_start = min_late_start - tasks[i].duration;
    }
}

// 计算任务的松弛时间
void calculateSlacks(Task tasks[]) {
    for (int i = 0; i < MAX_TASKS; i++) {
        tasks[i].slack = tasks[i].late_start - tasks[i].early_start;
    }
}

// 打印关键路径
void printCriticalPath(Task tasks[]) {
    printf("Critical Path: ");
    for (int i = 0; i < MAX_TASKS; i++) {
        if (tasks[i].slack == 0) {
            printf("%c ", tasks[i].name);
        }
    }
    printf("\n");
}

int main() {
    Task tasks[MAX_TASKS];
    initializeTasks(tasks);
    calculateEarlyTimes(tasks);
    calculateLateTimes(tasks);
    calculateSlacks(tasks);
    printCriticalPath(tasks);
    return 0;
}

输出结果：

Critical Path: A B C D E

该代码通过定义任务结构体，初始化任务信息，并根据依赖关系计算任务的最早开始时间和最早完成时间、最晚开始时间和最晚完成时间，然后计算任务的松弛时间，并打印出关键路径。在给定的案例中，关键路径为A -> B -> C -> D -> E