c语言实现时间片轮转算法

时间片轮转算法是一种常见的调度算法，以下是基于C语言实现的简单示例：

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

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

// 定义时间片大小
#define TIME_QUANTUM 2

// 定义队列结构体
typedef struct queue {
    Process* processes[100];
    int front;
    int rear;
} Queue;

// 初始化队列
Queue* initQueue() {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->front = 0;
    q->rear = 0;
    return q;
}

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

// 出队
Process* dequeue(Queue* q) {
    if (q->front == q->rear) {
        return NULL;
    }
    Process* p = q->processes[q->front];
    q->front++;
    return p;
}

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

// 时间片轮转算法
void roundRobin(Process* processes[], int n) {
    Queue* q = initQueue();
    int current_time = 0;
    int total_waiting_time = 0;
    int total_turnaround_time = 0;
    int total_executed_time = 0;
    int total_processes = n;

    // 将所有进程加入队列
    for (int i = 0; i < n; i++) {
        processes[i]->remaining_time = processes[i]->burst_time;
        enqueue(q, processes[i]);
    }

    // 执行队列中的进程
    while (!isQueueEmpty(q)) {
        Process* current_process = dequeue(q);
        int executed_time = current_process->remaining_time >= TIME_QUANTUM ? TIME_QUANTUM : current_process->remaining_time;
        current_process->remaining_time -= executed_time;
        total_executed_time += executed_time;
        current_time += executed_time;

        // 输出当前进程执行情况
        printf("Process %d executed for %d units. (Remaining time: %d)\n", current_process->pid, executed_time, current_process->remaining_time);

        // 将已执行完毕的进程从队列中删除
        if (current_process->remaining_time == 0) {
            int waiting_time = current_time - current_process->burst_time - current_process->arrival_time;
            int turnaround_time = current_time - current_process->arrival_time;
            total_waiting_time += waiting_time;
            total_turnaround_time += turnaround_time;
            printf("Process %d finished. (Waiting time: %d, Turnaround time: %d)\n", current_process->pid, waiting_time, turnaround_time);
        }
        // 将未执行完毕的进程加入队列尾部
        else {
            enqueue(q, current_process);
        }
    }

    // 输出平均等待时间和平均周转时间
    printf("Average waiting time: %.2f\n", (float)total_waiting_time / total_processes);
    printf("Average turnaround time: %.2f\n", (float)total_turnaround_time / total_processes);
}

// 测试
int main() {
    // 定义进程数组
    Process* processes[5];
    processes[0] = (Process*)malloc(sizeof(Process)); processes[0]->pid = 1; processes[0]->arrival_time = 0; processes[0]->burst_time = 8;
    processes[1] = (Process*)malloc(sizeof(Process)); processes[1]->pid = 2; processes[1]->arrival_time = 1; processes[1]->burst_time = 4;
    processes[2] = (Process*)malloc(sizeof(Process)); processes[2]->pid = 3; processes[2]->arrival_time = 2; processes[2]->burst_time = 9;
    processes[3] = (Process*)malloc(sizeof(Process)); processes[3]->pid = 4; processes[3]->arrival_time = 3; processes[3]->burst_time = 5;
    processes[4] = (Process*)malloc(sizeof(Process)); processes[4]->pid = 5; processes[4]->arrival_time = 4; processes[4]->burst_time = 2;

    // 执行时间片轮转算法
    roundRobin(processes, 5);

    return 0;
}

在上述示例中，我们定义了一个进程结构体，包含进程ID、到达时间、执行时间和剩余时间等信息。我们还定义了一个队列结构体，用于存储进程队列。

在 `roundRobin` 函数中，我们首先将所有进程加入队列，然后不断执行队列中的进程，直到队列为空。每次执行一个进程时，我们先判断该进程剩余时间是否小于时间片大小，若是则将整个进程执行完毕，否则只执行一个时间片大小的时间。执行完毕后，我们根据进程剩余时间判断该进程是否已经执行完毕，若已经执行完毕，则将其从队列中删除，否则将其加入队列尾部。最后，我们输出平均等待时间和平均周转时间。

在 `main` 函数中，我们定义了一个包含5个进程的进程数组，并调用 `roundRobin` 函数执行时间片轮转算法。