用C设计和实现单机调度算法

单机调度算法是指在单个处理器上对多个任务进行调度，使得任务能够尽快地完成，同时尽量减少等待时间和延迟。下面是一个简单的单机调度算法的实现：

1. 首先，读取所有任务的信息，包括任务名称、到达时间、执行时间等，并将它们存储在一个任务列表中。

2. 对任务列表按照到达时间进行排序，以保证任务按照到达时间的先后顺序进行调度。

3. 创建一个就绪队列，将所有到达时间小于等于当前时间的任务加入队列中。如果当前没有任务到达，则等待直到有任务到达。

4. 从就绪队列中选择一个任务进行执行。如果存在多个任务，则选择其中执行时间最短的任务。

5. 执行任务，更新当前时间，同时更新任务的状态和完成时间。

6. 如果还有任务未执行完，则返回第3步，否则停止算法。

下面是一个简单的 C 语言实现：

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

#define MAX_TASKS 100

typedef struct {
    char name[10];      // 任务名称
    int arrival_time;   // 到达时间
    int execute_time;   // 执行时间
    int start_time;     // 开始时间
    int finish_time;    // 完成时间
} Task;

void sort_tasks(Task tasks[], int n) {
    // 按照到达时间排序
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            if (tasks[i].arrival_time > tasks[j].arrival_time) {
                Task temp = tasks[i];
                tasks[i] = tasks[j];
                tasks[j] = temp;
            }
        }
    }
}

void schedule_tasks(Task tasks[], int n) {
    int current_time = 0;   // 当前时间
    int completed_tasks = 0;    // 已完成任务数
    Task ready_queue[MAX_TASKS];    // 就绪队列
    int queue_size = 0; // 就绪队列大小

    while (completed_tasks < n) {
        // 将到达时间小于等于当前时间的任务加入就绪队列
        for (int i = 0; i < n; i++) {
            if (tasks[i].arrival_time <= current_time && tasks[i].finish_time == 0) {
                ready_queue[queue_size++] = tasks[i];
            }
        }

        // 如果就绪队列为空，则等待直到有任务到达
        if (queue_size == 0) {
            current_time++;
            continue;
        }

        // 选择执行时间最短的任务
        int shortest_task = 0;
        for (int i = 1; i < queue_size; i++) {
            if (ready_queue[i].execute_time < ready_queue[shortest_task].execute_time) {
                shortest_task = i;
            }
        }

        // 执行任务
        Task *task = &ready_queue[shortest_task];
        task->start_time = current_time;
        task->finish_time = current_time + task->execute_time;
        current_time = task->finish_time;
        completed_tasks++;

        // 从就绪队列中删除已执行的任务
        for (int i = shortest_task; i < queue_size - 1; i++) {
            ready_queue[i] = ready_queue[i + 1];
        }
        queue_size--;
    }
}

void print_tasks(Task tasks[], int n) {
    printf("任务\t到达时间\t执行时间\t开始时间\t完成时间\n");
    for (int i = 0; i < n; i++) {
        printf("%s\t%d\t%d\t%d\t%d\n", tasks[i].name, tasks[i].arrival_time,
               tasks[i].execute_time, tasks[i].start_time, tasks[i].finish_time);
    }
}

int main() {
    Task tasks[MAX_TASKS];
    int n;

    printf("请输入任务数：");
    scanf("%d", &n);

    printf("请依次输入任务名称、到达时间、执行时间：\n");
    for (int i = 0; i < n; i++) {
        scanf("%s%d%d", tasks[i].name, &tasks[i].arrival_time, &tasks[i].execute_time);
    }

    sort_tasks(tasks, n);
    schedule_tasks(tasks, n);
    print_tasks(tasks, n);

    return 0;
}

以上代码实现了一个简单的单机调度算法，当然这只是一个基础的算法，实际情况中可能需要更复杂的算法来满足实际需求。