选择一个调度算法、编写 C 语言（或其他程序设计语言）程序，模拟多道系统中在单处 理器情况下的进程控制和进程调度。

我选择实现一个简单的先来先服务（FCFS）调度算法的模拟程序。

程序首先需要定义进程（Process）的数据结构，包括进程的 ID，到达时间、服务时间和完成时间等属性：

typedef struct process {
    int id;           // 进程 ID
    int arrival_time; // 到达时间
    int service_time; // 服务时间
    int finish_time;  // 完成时间
    int turnaround_time; // 周转时间
    int waiting_time;    // 等待时间
} Process;

接下来，我们需要定义一个进程队列，并实现进程的排序函数，按照到达时间排序：

typedef struct process_node {
    Process *process;
    struct process_node *next;
} ProcessNode;

typedef struct process_queue {
    ProcessNode *head;
    ProcessNode *tail;
    int size;
} ProcessQueue;

int compare_processes(const void *a, const void *b) {
    Process *pa = *(Process **)a;
    Process *pb = *(Process **)b;
    return pa->arrival_time - pb->arrival_time;
}

void enqueue_process(ProcessQueue *queue, Process *process) {
    ProcessNode *node = (ProcessNode *)malloc(sizeof(ProcessNode));
    node->process = process;
    node->next = NULL;
    if (queue->tail == NULL) {
        queue->head = node;
        queue->tail = node;
    } else {
        queue->tail->next = node;
        queue->tail = node;
    }
    queue->size++;
}

Process *dequeue_process(ProcessQueue *queue) {
    if (queue->head == NULL) {
        return NULL;
    }
    ProcessNode *node = queue->head;
    queue->head = node->next;
    if (queue->head == NULL) {
        queue->tail = NULL;
    }
    queue->size--;
    Process *process = node->process;
    free(node);
    return process;
}

void sort_processes(Process **processes, int n) {
    qsort(processes, n, sizeof(Process *), compare_processes);
}

然后，我们可以实现 FCFS 调度算法的主函数。该函数首先将所有进程按照到达时间排序，然后依次执行每个进程，计算完成时间、周转时间和等待时间：

void fcfs_schedule(Process **processes, int n) {
    sort_processes(processes, n);
    int current_time = 0;
    for (int i = 0; i < n; i++) {
        Process *process = processes[i];
        if (process->arrival_time > current_time) {
            current_time = process->arrival_time;
        }
        process->finish_time = current_time + process->service_time;
        process->turnaround_time = process->finish_time - process->arrival_time;
        process->waiting_time = process->turnaround_time - process->service_time;
        current_time = process->finish_time;
    }
}

最后，我们可以定义一些辅助函数，比如读取进程信息，打印进程信息和计算平均周转时间和平均等待时间：

Process *read_process_info(int id) {
    Process *process = (Process *)malloc(sizeof(Process));
    printf("Enter arrival time and service time for process %d: ", id);
    scanf("%d %d", &process->arrival_time, &process->service_time);
    process->id = id;
    process->finish_time = 0;
    process->turnaround_time = 0;
    process->waiting_time = 0;
    return process;
}

void print_process_info(Process *process) {
    printf("Process %d: arrival_time=%d, service_time=%d, finish_time=%d, turnaround_time=%d, waiting_time=%d\n",
        process->id, process->arrival_time, process->service_time, process->finish_time,
        process->turnaround_time, process->waiting_time);
}

void print_average_times(Process **processes, int n) {
    int total_turnaround_time = 0;
    int total_waiting_time = 0;
    for (int i = 0; i < n; i++) {
        Process *process = processes[i];
        total_turnaround_time += process->turnaround_time;
        total_waiting_time += process->waiting_time;
    }
    double avg_turnaround_time = (double)total_turnaround_time / n;
    double avg_waiting_time = (double)total_waiting_time / n;
    printf("Average turnaround time: %.2f\n", avg_turnaround_time);
    printf("Average waiting time: %.2f\n", avg_waiting_time);
}

最终，我们可以编写一个完整的程序，读取多个进程的信息，调用 FCFS 调度算法，打印每个进程的信息和平均周转时间和平均等待时间：

#define MAX_PROCESSES 100

int main() {
    int n;
    printf("Enter the number of processes (maximum %d): ", MAX_PROCESSES);
    scanf("%d", &n);
    if (n > MAX_PROCESSES) {
        printf("Error: too many processes\n");
        return 1;
    }
    Process *processes[MAX_PROCESSES];
    for (int i = 0; i < n; i++) {
        processes[i] = read_process_info(i);
    }
    fcfs_schedule(processes, n);
    for (int i = 0; i < n; i++) {
        print_process_info(processes[i]);
    }
    print_average_times(processes, n);
    for (int i = 0; i < n; i++) {
        free(processes[i]);
    }
    return 0;
}