编程进程或作业按时间片轮转调度算法代码

以下是一个时间片轮转调度算法的代码示例，使用C++语言实现：

#include<iostream>
#include<queue>
using namespace std;

struct Process{
    int pid; // 进程ID
    int burst_time; // 进程需要执行的时间
    int remaining_time; // 进程剩余执行时间
};

void round_robin(Process processes[], int n, int time_quantum){
    queue<Process> ready_queue; // 就绪队列
    int total_time = 0; // 总时间
    int total_waiting_time = 0; // 总等待时间
    
    // 将所有进程加入就绪队列
    for(int i=0; i<n; i++){
        ready_queue.push(processes[i]);
    }
    
    // 执行就绪队列中的进程
    while(!ready_queue.empty()){
        Process current_process = ready_queue.front(); // 获取当前进程
        ready_queue.pop();
        
        // 如果当前进程需要的时间小于时间片，则直接执行完该进程
        if(current_process.remaining_time <= time_quantum){
            total_time += current_process.remaining_time;
            current_process.remaining_time = 0;
        }
        // 如果当前进程需要的时间大于时间片，则执行一个时间片
        else{
            total_time += time_quantum;
            current_process.remaining_time -= time_quantum;
        }
        
        // 将已执行完一次时间片的进程重新加入就绪队列
        for(int i=0; i<n; i++){
            if(processes[i].pid == current_process.pid){
                processes[i].remaining_time = current_process.remaining_time;
            }
            else if(processes[i].remaining_time > 0){
                ready_queue.push(processes[i]);
            }
        }
        
        // 如果当前进程未执行完，则将其重新加入就绪队列
        if(current_process.remaining_time > 0){
            ready_queue.push(current_process);
        }
        // 如果当前进程已执行完，则计算该进程的等待时间
        else{
            int waiting_time = total_time - current_process.burst_time;
            total_waiting_time += waiting_time;
        }
    }
    
    // 计算平均等待时间
    double avg_waiting_time = (double)total_waiting_time / n;
    cout << "Average waiting time: " << avg_waiting_time << endl;
}

int main(){
    Process processes[] = {
        {1, 10, 10},
        {2, 5, 5},
        {3, 8, 8},
        {4, 7, 7},
        {5, 3, 3}
    };
    int n = sizeof(processes) / sizeof(Process);
    int time_quantum = 2;
    
    round_robin(processes, n, time_quantum);
    
    return 0;
}

该代码使用一个结构体来表示进程，包括进程ID、需要执行的时间和剩余执行时间。首先将所有进程加入就绪队列，然后循环执行就绪队列中的进程，每次执行一个时间片（如果该进程需要的时间小于时间片，则直接执行完该进程），然后将已执行完一次时间片的进程重新加入就绪队列。如果当前进程未执行完，则将其重新加入就绪队列；如果当前进程已执行完，则计算该进程的等待时间，并将其从就绪队列中移除。最后计算平均等待时间并输出。