时间片轮转 进程调度算法的模拟 c语言

好的，我可以给您提供一个时间片轮转进程调度算法的模拟程序，使用C语言编写，如下所示：

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

#define MAX_SIZE 100

// 进程控制块
typedef struct {
    int pid;  // 进程ID
    int burst_time;  // 进程执行时间
    int remain_time;  // 进程剩余执行时间
    int arrival_time;  // 进程到达时间
    int waiting_time;  // 进程等待时间
} PCB;

// 队列
typedef struct {
    PCB *items[MAX_SIZE];
    int front, rear;
} Queue;

// 初始化队列
void init_queue(Queue *q) {
    q->front = q->rear = 0;
}

// 判断队列是否为空
int is_empty(Queue *q) {
    return q->front == q->rear;
}

// 入队
void enqueue(Queue *q, PCB *p) {
    q->items[q->rear++] = p;
}

// 出队
PCB *dequeue(Queue *q) {
    return q->items[q->front++];
}

// 获取队首元素
PCB *front(Queue *q) {
    return q->items[q->front];
}

// 时间片轮转算法
void round_robin(PCB **processes, int num_processes, int quantum) {
    Queue ready_queue;
    init_queue(&ready_queue);
    int current_time = 0;
    int completed = 0;
    while (completed < num_processes) {
        // 将到达时间小于当前时间的进程加入就绪队列
        for (int i = 0; i < num_processes; i++) {
            if (processes[i]->arrival_time <= current_time && processes[i]->remain_time > 0) {
                enqueue(&ready_queue, processes[i]);
            }
        }
        // 如果就绪队列为空，则时间跳到下一个进程到达时间
        if (is_empty(&ready_queue)) {
            current_time++;
            continue;
        }
        // 从队首取出一个进程
        PCB *current_process = dequeue(&ready_queue);
        // 如果进程剩余执行时间小于时间片，则执行完该进程
        if (current_process->remain_time <= quantum) {
            current_time += current_process->remain_time;
            current_process->remain_time = 0;
            current_process->waiting_time = current_time - current_process->burst_time - current_process->arrival_time;
            completed++;
        }
        // 否则执行一段时间后放回队尾
        else {
            current_time += quantum;
            current_process->remain_time -= quantum;
            enqueue(&ready_queue, current_process);
        }
    }
}

int main() {
    int num_processes, quantum;
    printf("请输入进程数量和时间片大小：");
    scanf("%d %d", &num_processes, &quantum);
    PCB **processes = malloc(num_processes * sizeof(PCB *));
    printf("请输入每个进程的到达时间和执行时间：\n");
    for (int i = 0; i < num_processes; i++) {
        processes[i] = malloc(sizeof(PCB));
        printf("进程 %d：", i + 1);
        scanf("%d %d", &processes[i]->arrival_time, &processes[i]->burst_time);
        processes[i]->pid = i + 1;
        processes[i]->remain_time = processes[i]->burst_time;
    }
    round_robin(processes, num_processes, quantum);
    printf("进程\t等待时间\n");
    int total_waiting_time = 0;
    for (int i = 0; i < num_processes; i++) {
        total_waiting_time += processes[i]->waiting_time;
        printf("%d\t%d\n", processes[i]->pid, processes[i]->waiting_time);
    }
    printf("平均等待时间：%f\n", (float)total_waiting_time / num_processes);
    return 0;
}

该程序实现了时间片轮转算法的模拟，用户可以输入进程数量和时间片大小，以及每个进程的到达时间和执行时间。程序根据输入的信息模拟进程的执行过程，并输出每个进程的等待时间和平均等待时间。

注意，为了避免重复，我在程序中没有使用您提供的那段话。