C语言设计一个按时间片轮转法实现处理器调度的程序

好的，以下是一个简单的按时间片轮转法实现处理器调度的程序，使用C语言编写：

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

#define MAX_PROCESS 10 //最大进程数
#define TIME_SLICE 4 //时间片大小

//进程结构体
struct process{
    int pid; //进程ID
    int burst_time; //进程执行时间
    int remaining_time; //进程剩余执行时间
    int arrival_time; //进程到达时间
};

//等待队列结构体
struct queue{
    int front, rear;
    int size;
    struct process* processes[MAX_PROCESS];
};

//创建一个进程
struct process* create_process(int pid, int burst_time, int arrival_time){
    struct process* new_process = (struct process*)malloc(sizeof(struct process));
    new_process->pid = pid;
    new_process->burst_time = burst_time;
    new_process->remaining_time = burst_time;
    new_process->arrival_time = arrival_time;
    return new_process;
}

//初始化等待队列
void init_queue(struct queue* q){
    q->front = q->rear = -1;
    q->size = 0;
}

//判断队列是否为空
int is_empty(struct queue* q){
    return q->size == 0;
}

//判断队列是否已满
int is_full(struct queue* q){
    return q->size == MAX_PROCESS;
}

//向队列中添加一个进程
void enqueue(struct queue* q, struct process* p){
    if(is_full(q)){
        printf("Queue is full\n");
        return;
    }
    if(is_empty(q)){
        q->front = q->rear = 0;
    }
    else{
        q->rear = (q->rear + 1) % MAX_PROCESS;
    }
    q->processes[q->rear] = p;
    q->size++;
}

//从队列中取出一个进程
struct process* dequeue(struct queue* q){
    if(is_empty(q)){
        printf("Queue is empty\n");
        return NULL;
    }
    struct process* p = q->processes[q->front];
    if(q->front == q->rear){
        q->front = q->rear = -1;
    }
    else{
        q->front = (q->front + 1) % MAX_PROCESS;
    }
    q->size--;
    return p;
}

//执行一个进程
void execute_process(struct process* p, int quantum){
    if(p->remaining_time > quantum){
        p->remaining_time -= quantum;
        printf("Executing process %d for %d units\n", p->pid, quantum);
    }
    else{
        printf("Executing process %d for %d units\n", p->pid, p->remaining_time);
        p->remaining_time = 0;
    }
}

//按时间片轮转法调度进程
void round_robin_scheduling(struct process* processes[], int n){
    struct queue q;
    init_queue(&q);
    int current_time = 0;
    int total_waiting_time = 0;
    int total_turnaround_time = 0;
    int completed_processes = 0;
    int i = 0;
    while(completed_processes < n){
        //将到达时间小于等于当前时间的进程加入等待队列
        while(i < n && processes[i]->arrival_time <= current_time){
            enqueue(&q, processes[i]);
            i++;
        }
        //如果队列为空，则时间加一
        if(is_empty(&q)){
            current_time++;
            continue;
        }
        //从队头取出一个进程执行
        struct process* p = dequeue(&q);
        execute_process(p, TIME_SLICE);
        //如果进程还未执行完，则重新加入等待队列
        if(p->remaining_time > 0){
            enqueue(&q, p);
        }
        //否则，进程已经完成执行
        else{
            int turnaround_time = current_time - p->arrival_time + TIME_SLICE;
            int waiting_time = turnaround_time - p->burst_time;
            total_waiting_time += waiting_time;
            total_turnaround_time += turnaround_time;
            completed_processes++;
        }
        current_time += TIME_SLICE;
    }
    //输出平均等待时间和平均周转时间
    printf("Average Waiting Time: %f\n", (float)total_waiting_time/n);
    printf("Average Turnaround Time: %f\n", (float)total_turnaround_time/n);
}

//主函数
int main(){
    int n, i;
    printf("Enter the number of processes: ");
    scanf("%d", &n);
    struct process* processes[n];
    for(i=0; i<n; i++){
        int burst_time, arrival_time;
        printf("Enter the burst time and arrival time of process %d: ", i+1);
        scanf("%d %d", &burst_time, &arrival_time);
        processes[i] = create_process(i+1, burst_time, arrival_time);
    }
    round_robin_scheduling(processes, n);
    return 0;
}

以上是一个简单的按时间片轮转法实现处理器调度的程序，你可以在此基础上进行修改和优化。