用c语言编程 内容：进程调度算法设计 （优先数算法或时间片轮转法）

以下是时间片轮转法的进程调度算法设计示例：

#include<stdio.h>

#define MAX_PROCESS 10

// 进程结构体
struct Process {
    char name[10];  // 进程名
    int arrivalTime;  // 到达时间
    int burstTime;  // 执行时间
    int remainingTime;  // 剩余时间
    int turnaroundTime;  // 周转时间
    int waitingTime;  // 等待时间
    int completed;  // 是否完成
};

// 就绪队列
struct Process readyQueue[MAX_PROCESS];

// 添加进程到就绪队列
void addProcess(struct Process process, int *rear) {
    readyQueue[*rear] = process;
    (*rear)++;
}

// 时间片轮转法调度算法
void roundRobinScheduling(struct Process processes[], int n, int quantum) {
    int time = 0;  // 当前时间
    int rear = 0;  // 就绪队列尾指针
    int completed = 0;  // 完成进程数
    int i;
    
    // 将所有进程加入就绪队列
    for (i = 0; i < n; i++) {
        addProcess(processes[i], &rear);
    }
    
    // 循环调度进程
    while (completed < n) {
        // 取出队首进程
        struct Process current = readyQueue[0];
        // 执行时间为 quantum 或剩余时间（如果剩余时间小于 quantum）
        int executeTime = current.remainingTime < quantum ? current.remainingTime : quantum;
        // 更新剩余时间
        current.remainingTime -= executeTime;
        // 更新当前时间
        time += executeTime;
        // 更新等待时间和周转时间
        for (i = 0; i < rear; i++) {
            if (readyQueue[i].arrivalTime <= time && !readyQueue[i].completed) {
                readyQueue[i].waitingTime += time - readyQueue[i].turnaroundTime;
                readyQueue[i].turnaroundTime = time - readyQueue[i].arrivalTime;
            }
        }
        // 如果进程还未完成，重新加入就绪队列
        if (current.remainingTime > 0) {
            readyQueue[rear] = current;
            rear++;
        }
        // 如果进程已经完成，更新统计信息
        else {
            current.completed = 1;
            current.turnaroundTime = time - current.arrivalTime;
            current.waitingTime = current.turnaroundTime - current.burstTime;
            printf("%s 完成! 周转时间: %d, 等待时间: %d\n", current.name, current.turnaroundTime, current.waitingTime);
            completed++;
        }
        // 将队首进程移到队尾
        for (i = 0; i < rear - 1; i++) {
            readyQueue[i] = readyQueue[i + 1];
        }
        rear--;
        readyQueue[rear] = current;
    }
}

int main() {
    struct Process processes[MAX_PROCESS] = {
        {"P1", 0, 10, 10},
        {"P2", 1, 5, 5},
        {"P3", 2, 7, 7},
        {"P4", 3, 8, 8},
        {"P5", 4, 6, 6},
    };
    int n = 5;  // 进程数
    int quantum = 2;  // 时间片大小
    roundRobinScheduling(processes, n, quantum);
    return 0;
}

在上面的示例中，我们定义了进程结构体 `struct Process`，其中包含进程名、到达时间、执行时间、剩余时间、周转时间、等待时间和完成标志等信息。我们还定义了就绪队列 `readyQueue`，用于存放已经到达但未执行的进程。

在 `roundRobinScheduling` 函数中，我们首先将所有进程加入就绪队列。然后，我们循环调度进程，直到所有进程都完成。每次调度时，我们从就绪队列中取出队首进程，执行时间为 quantum 或剩余时间（如果剩余时间小于 quantum）。然后更新剩余时间、当前时间、等待时间和周转时间等信息。如果进程还未完成，重新加入就绪队列；如果进程已经完成，更新统计信息并打印出来。最后，我们将队首进程移到队尾。

在 `main` 函数中，我们定义了一个包含 5 个进程的进程数组 `processes`，以及时间片大小 `quantum`。然后，我们调用 `roundRobinScheduling` 函数，传入进程数组和时间片大小，进行时间片轮转法调度。