进程调度C语言实现

合集下载

进程调度算法c语言

char state;//进程状态，包括R=run W=wait F=finish
struct pcb *next;
}pcb,ready[10];
struct pcb *creat(k)//测试通过
{
int a,t=0;
struct pcb *head,*p1,*p2;
{ int i; //printf函数只需输出一次就绪态或执行后的进程队伍就可以了，
struct pcb *p; //不需要执行所有的时间片，把时间片初和末轮转和时间片轮转都放到main函数里面
p=head;//将链表的头指针赋给p
for(i=0,j=0;i<n&&p!=null;i++)
{ if(p->artime<time)
{ ready[j++]=*p;//将进程赋给ready[0]，进程数k加1
p=p->next;//p向后移一位
}
else
{swap(p+n,p+n+1);
}
}
}
head=p;
}
return head;
}
void print(struct pcb *head,int number,int q)//head为ready的头指针，number是就绪态进程的个数……测试通过
head=creat(i);
printf(" 就绪进队伍打印表 \n");
printf(" 时间片名称到达时间需要时间优先级已用时间状态\n");
srand(time(0));

操作系统进程调度C语言代码

操作系统进程调度C语言代码操作系统是计算机系统中的重要组成部分，用于管理和控制计算机资源的分配和使用。

在操作系统中，进程调度是指将系统资源（如 CPU、内存、磁盘、网络等）分配给运行中的进程的过程。

进程调度是操作系统实现多任务、多用户和分时系统的关键。

进程调度的算法有多种。

最常见的是时间片轮转算法、优先级调度算法、最短进程优先算法和先到先服务算法等。

下面我们将介绍一下时间片轮转算法的 C 语言代码实现。

1. 时间片轮转算法时间片轮转算法是一种基于时间片的调度算法，它给每个进程分配一个时间片，当时间片用完后，系统将进程暂停，并将 CPU 分配给下一个进程。

时间片轮转算法可以让所有进程公平地使用 CPU 时间，并且可以避免进程饥饿的情况发生。

2. C 语言代码实现在 C 语言中，可以用结构体来表示一个进程，包括进程 ID、进程状态、优先级、到达时间和需要运行的时间片等属性。

下面是一个简单的进程结构体的定义：```struct Process processes[5];在实现时间片轮转算法之前，需要先实现一个进程调度函数，它的作用是找到就绪进程中优先级最高的进程，并返回它的位置。

下面是一个简单的进程调度函数：```int find_highest_priority_process(struct Process *processes, int n) {int highest_priority = -1;int highest_priority_index = -1;for (int i = 0; i < n; i++) {if (processes[i].state != 2 && processes[i].priority >highest_priority) {highest_priority = processes[i].priority;highest_priority_index = i;}}return highest_priority_index;}```在实现时间片轮转算法之前，需要先定义一些全局变量，包括就绪队列、当前时间、时间片大小和进程数量等。

进程调度实验报告

进程调度实验报告一、实验目的。

本实验旨在通过对进程调度算法的模拟和实验，加深学生对进程调度原理的理解，掌握各种进程调度算法的特点和应用场景，提高学生的实际操作能力和分析问题的能力。

二、实验环境。

本次实验使用了C语言编程语言，通过模拟实现了先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和多级反馈队列（MFQ）四种进程调度算法。

三、实验过程。

1. 先来先服务（FCFS）调度算法。

先来先服务调度算法是一种非抢占式的调度算法，按照进程到达的先后顺序进行调度。

在本次实验中，我们通过模拟多个进程到达并排队等待CPU执行，观察其平均等待时间和平均周转时间。

实验结果表明，先来先服务调度算法适用于作业长度差异较大的情况，但容易产生“饥饿”现象。

2. 最短作业优先（SJF）调度算法。

最短作业优先调度算法是一种非抢占式的调度算法，按照作业执行时间的长短进行调度。

在本次实验中，我们通过模拟多个作业的执行时间，观察其平均等待时间和平均周转时间。

实验结果表明，最短作业优先调度算法能够最大程度地减少平均等待时间，但可能会导致长作业被“饿死”。

3. 时间片轮转（RR）调度算法。

时间片轮转调度算法是一种抢占式的调度算法，每个进程被分配一个时间片，当时间片用完后，该进程被放到队尾等待。

在本次实验中，我们通过模拟多个进程的执行和时间片的调度，观察其平均等待时间和平均周转时间。

实验结果表明，时间片轮转调度算法能够保证每个进程都能得到一定的执行时间，但可能会导致上下文切换频繁。

4. 多级反馈队列（MFQ）调度算法。

多级反馈队列调度算法是一种综合性的调度算法，根据进程的优先级和执行时间进行动态调整。

在本次实验中，我们通过模拟多个进程的执行和不同优先级队列的调度，观察其平均等待时间和平均周转时间。

实验结果表明，多级反馈队列调度算法能够兼顾短作业和长作业，提高了系统的整体性能。

四、实验总结。

通过本次实验，我们深入理解了不同进程调度算法的特点和适用场景。

调度算法C语言实现

调度算法C语言实现调度算法是操作系统中的重要内容之一，它决定了进程在系统中的运行方式和顺序。

本文将介绍两种常见的调度算法，先来先服务（FCFS）和最短作业优先（SJF），并用C语言实现它们。

一、先来先服务（FCFS）调度算法先来先服务（FCFS）调度算法是最简单的调度算法之一、它按照进程到达的先后顺序进行调度，即谁先到达就先执行。

实现这个算法的关键是记录进程到达的顺序和每个进程的执行时间。

下面是一个用C语言实现先来先服务调度算法的示例程序：```c#include <stdio.h>//进程控制块结构体typedef structint pid; // 进程IDint arrivalTime; // 到达时间int burstTime; // 执行时间} Process;int maiint n; // 进程数量printf("请输入进程数量：");scanf("%d", &n);//输入每个进程的到达时间和执行时间Process process[n];for (int i = 0; i < n; i++)printf("请输入进程 %d 的到达时间和执行时间：", i);scanf("%d%d", &process[i].arrivalTime,&process[i].burstTime);process[i].pid = i;}//根据到达时间排序进程for (int i = 0; i < n - 1; i++)for (int j = i + 1; j < n; j++)if (process[i].arrivalTime > process[j].arrivalTime) Process temp = process[i];process[i] = process[j];process[j] = temp;}}}//计算平均等待时间和平均周转时间float totalWaitingTime = 0; // 总等待时间float totalTurnaroundTime = 0; // 总周转时间int currentTime = 0; // 当前时间for (int i = 0; i < n; i++)if (currentTime < process[i].arrivalTime)currentTime = process[i].arrivalTime;}totalWaitingTime += currentTime - process[i].arrivalTime;totalTurnaroundTime += (currentTime + process[i].burstTime) - process[i].arrivalTime;currentTime += process[i].burstTime;}//输出结果float avgWaitingTime = totalWaitingTime / n;float avgTurnaroundTime = totalTurnaroundTime / n;printf("平均等待时间：%f\n", avgWaitingTime);printf("平均周转时间：%f\n", avgTurnaroundTime);return 0;```以上程序实现了先来先服务（FCFS）调度算法，首先根据进程的到达时间排序，然后依次执行每个进程，并计算总等待时间和总周转时间。

操作系统进程调度C语言代码

操作系统进程调度C语言代码#include <stdio.h>#define MAX 20//进程控制块typedef struct PCBchar name[10]; // 进程名int AT; // 到达时间int BT; // 服务时间int Pri; // 优先数int FT; // 完成时间int WT; //等待时间int RT; // 响应时间int position; // 第几号进程int flag; // 用来判断进程是否执行过}PCB;//进程调度void schedule(PCB a[], int n, int alg)int i, j, k, flag, temp;int count = 0;int pri_max = 0;float ATAT = 0.0;float AWT = 0.0;float ART = 0.0;PCBt;//各种算法的调度if (alg == 1)printf("采用先来先服务调度：\n"); //根据到达时间执行for (i = 0; i < n; i++)for (j = i + 1; j < n; j++)if (a[i].AT > a[j].AT)t=a[i];a[i]=a[j];a[j]=t;}//按到达时间依次执行for (i = 0; count != n; i++)for (j = 0; j < n; j++)//查找第一个到达时间小于等于当前时间的进程if (a[j].AT <= i && a[j].flag == 0)//记录运行时间a[j].BT--;//如果运行完成，记录完成时间、等待时间、响应时间if (a[j].BT == 0)a[j].FT=i+1;a[j].WT = a[j].FT - a[j].AT - a[j].Pri;a[j].RT=a[j].WT;a[j].flag = 1;count++;}elsebreak;}}}else if (alg == 2)printf("采用最短服务时间优先（非抢占）调度：\n");for (i = 0; count != n; i++)//找出服务时间最短的进程，并将其放置到最前面for (j = 0; j < n; j++)。

c语言实现进程调度算法

c语言实现进程调度算法进程调度算法是操作系统中的一个重要组成部分，用于决定在多道程序环境下，选择哪个进程来占用CPU并执行。

C语言是一种通用的编程语言，可以用于实现各种进程调度算法。

这里我将分别介绍三种常见的进程调度算法：先来先服务调度算法（FCFS）、最短作业优先调度算法（SJF）和轮转法调度算法（RR），并给出用C语言实现的示例代码。

首先，我们来看先来先服务调度算法（FCFS）。

此算法根据到达时间的先后顺序，按照先来后到的顺序进行处理。

下面是基于C语言的先来先服务调度算法实现示例代码：```c#include<stdio.h>struct Process};void FCFS(struct Process proc[], int n)for (int i = 1; i < n; i++)}printf("进程号到达时间服务时间完成时间等待时间周转时间\n");for (int i = 0; i < n; i++)}for (int i = 0; i < n; i++)}int maiint n;printf("请输入进程数：");scanf("%d", &n);struct Process proc[n];for (int i = 0; i < n; i++)printf("请输入进程%d的到达时间和服务时间（用空格分隔）：", i + 1);}FCFS(proc, n);return 0;```其次，我们来看最短作业优先调度算法（SJF），该算法选择执行时间最短的进程先执行。

下面是基于C语言的最短作业优先调度算法实现示例代码：```c#include<stdio.h>struct Process};void SJF(struct Process proc[], int n)for (int i = 0; i < n; i++)for (int j = 0; j < i; j++)}shortest_job = i;for (int j = i + 1; j < n; j++)shortest_job = j;}}}for (int i = 1; i < n; i++)}printf("进程号到达时间服务时间完成时间等待时间周转时间\n");for (int i = 0; i < n; i++)}for (int i = 0; i < n; i++)}int maiint n;printf("请输入进程数：");scanf("%d", &n);struct Process proc[n];for (int i = 0; i < n; i++)printf("请输入进程%d的到达时间和服务时间（用空格分隔）：", i + 1);}SJF(proc, n);return 0;```最后，我们来看轮转法调度算法（RR），该算法分配一个时间片给每个进程，当时间片用完后，将CPU分配给下一个进程。

操作系统进程调度优先级算法C语言模拟

操作系统进程调度优先级算法C语言模拟```cstruct Processint pid; // 进程IDint priority; // 优先级};```接下来，我们使用一个简单的示例来说明操作系统进程调度优先级算法的模拟实现。

假设有5个进程需要调度执行，它们的初始优先级和运行时间如下：进程ID，优先级，已运行时间--------，--------，------------P1，4，2P2，3，4P3，1，6P4，2，1P5，5，3首先，我们需要将这些进程按照优先级排序，以得到调度队列。

可以使用冒泡排序算法实现，代码如下：```cvoid bubbleSort(struct Process *processes, int n)for (int i = 0; i < n - 1; i++)for (int j = 0; j < n - i - 1; j++)if (processes[j].priority > processes[j + 1].priority)struct Process temp = processes[j];processes[j] = processes[j + 1];processes[j + 1] = temp;}}}``````c#include <stdio.h>void bubbleSort(struct Process *processes, int n);int maistruct Process processes[] = {{1, 4, 2}, {2, 3, 4}, {3, 1, 6}, {4, 2, 1}, {5, 5, 3}};int n = sizeof(processes) / sizeof(struct Process);bubbleSort(processes, n);printf("初始调度队列：\n");printf("进程ID\t优先级\t已运行时间\n");for (int i = 0; i < n; i++)}//模拟进程调度printf("\n开始模拟进程调度...\n");int finished = 0;while (finished < n)struct Process *current_process = &processes[0];printf("执行进程 P%d\n", current_process->pid);finished++;printf("进程 P%d 执行完毕\n", current_process->pid);} else}bubbleSort(processes, n);}printf("\n所有进程执行完毕，调度队列的最终顺序为：\n"); printf("进程ID\t优先级\t已运行时间\n");for (int i = 0; i < n; i++)}return 0;```以上代码中，我们使用了一个变量`finished`来记录已完成的进程数量，当`finished`等于进程数量`n`时，所有进程执行完毕。

操作系统五种进程调度算法的代码

操作系统五种进程调度算法的代码一、先来先服务（FCFS）调度算法先来先服务（FCFS）调度算法是操作系统处理进程调度时比较常用的算法，它的基本思想是按照进程的提交时间的先后顺序依次调度进程，新提交的进程会在当前运行进程之后排队，下面通过C语言代码来实现先来先服务（FCFS）调度算法：#include <stdio.h>#include <stdlib.h>//定义进程的数据结构struct Processint pid; // 进程标识符int at; // 到达时间int bt; // 执行时间};//进程调度函数void fcfs_schedule(struct Process *processes, int n)int i, j;//根据进程的到达时间排序for(i = 0; i < n; i++)for(j = i+1; j < n; j++)if(processes[i].at > processes[j].at) struct Process temp = processes[i]; processes[i] = processes[j];processes[j] = temp;//获取各个进程执行完毕的时间int ct[n];ct[0] = processes[0].at + processes[0].bt; for(i = 1; i < n; i++)if(ct[i-1] > processes[i].at)ct[i] = ct[i-1] + processes[i].bt;elsect[i] = processes[i].at + processes[i].bt; //计算各个进程的周转时间和带权周转时间int tat[n], wt[n], wt_r[n];for(i = 0; i < n; i++)tat[i] = ct[i] - processes[i].at;wt[i] = tat[i] - processes[i].bt;wt_r[i] = wt[i] / processes[i].bt;printf("P%d:\tAT=%d\tBT=%d\tCT=%d\tTAT=%d\tWT=%d\tWT_R=%f\n", processes[i].pid, processes[i].at, processes[i].bt, ct[i], tat[i], wt[i], wt_r[i]);//主函数int mainstruct Process processes[] ={1,0,3},{2,3,5},{3,4,6},{4,5,2},{5,6,4}};fcfs_schedule(processes, 5);return 0;输出：。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

#include<stdio.h>#include<stdio.h>#include<malloc.h>typedef struct ProcessNode{ // 进程结点的基本结构char name; // 进程名int service_time; // 服务时间int arrive_time; // 到达时间int priority; // 优先级struct FCFS_time{ // 先到先服务int finish_time; // 完成时间int turnaround_time; // 周转时间float weigtharound_time;// 带权周转时间}FCFS_time;struct SJF_time{ // 短作业优先int finish_time;int turnaround_time;float weigtharound_time;int flag;}SJF_time;struct RR_time{ // 时间片轮转的结点int finish_time;int turnaround_time;float weigtharound_time;int flag_time;// 赋值为进程的服务时间，为0 则进程完成}RR_time;struct Pri_time{ // 优先权非抢占式int finish_time;int turnaround_time;float weigtharound_time;}Pri_time;struct ProcessNode*next;}ProcessNode,*Linklist;void main(){int choice;Linklist read_information();Linklist FCFS_scheduling(Linklist head);Linklist SJF_scheduling(Linklist head);Linklist RR_scheduling(Linklist head);Linklist Pri_scheduling(Linklist head);head=read_information();// 读入进程的基本信息do{p=head->next;printf("\n");printf("\n");printf(" 请在 1—5 之间选择 : ");scanf("%d",&choice);printf("\n");printf("\n"); printf(" ********** 进程初始信息输出 ********** \n");输出初始化后的进程基本信息 printf("\n");printf(" 进程名称 ");printf(" 到达时间 ");printf(" 服务时间 ");printf(" 优先级 ");printf("\n");while(p){printf(" %c ",p->name);printf(" %d ",p->arrive_time);printf(" %d ",p->service_time); printf(" %d",p->priority);printf("\n");p=p->next;}printf("\n");printf(" ************************************ \n");//输出进程的调用选择项 printf("\n");printf("1 、FCFS---先- 到先服务\n"); printf("2 、SJF 短作业优先\n");printf("3 、 RR ---- 时间片轮转 \n");printf("4 、Pri ----- 优先权调度 \n");printf("\n"); printf(" ************************************ \n");{case 1: FCFS_scheduling(head); break;case 2: SJF_scheduling(head);break;case 3: RR_scheduling(head); break;case 4: Pri_scheduling(head); break;// case 5: exit();}}while(choice!=5);Linklist read_information()// 进程读入函数{int i;int num;// ProcessNode ; Linklist pro; Linklist p; Linklist head;printf("\n");printf(" ************ 进程调度算法************ \n");printf("\n");printf(" 请输入进程的个数:");scanf("%d",&num);printf("\n");printf(" ************* 初始化信息************* \n");printf("\n");head=(Linklist)malloc(sizeof(ProcessNode));// 头结点head->next=NULL;p=head;for(i=1;i<=num;i++){pro=(Linklist)malloc(sizeof(ProcessNode));// 创建进程结点printf（" 输入第%d 个进程信息:\n",i）;printf(" 请输入进程名: ");fflush(stdin);scanf("%c",&pro->name);printf(" 到达时间: ");scanf("%d",&pro->arrive_time);printf(" 服务时间: ");scanf("%d",&pro->service_time);printf(”优先级f :");scanf("%d",&pro->priority);//pro->next=head->next; head->next=pro;// 逆序建链p->next=pro; p=pro;// 顺序建链//p++;pro->next=NULL;}printf("\n");return head;}Linklist FCFS_scheduling(Linklist head)// 先到先服务算法函数Linklist p;Linklist q;// 指向前一进程p=head->next;while(p) // 初始化进程的完成时间、周转时间、带权周转时间，初值均赋为0{p->FCFS_time.finish_time=0;p->FCFS_time.turnaround_time=0;p->FCFS_time.weigtharound_time=0;p=p->next;}p=q=head->next;p->FCFS_time.finish_time=p->arrive_time;// 避免第一个进程到达时间不为0 while(p){if(p->arrive_time<=q->FCFS_time.finish_time)// 下一进程已到达，在等待中{p->FCFS_time.finish_time=(p->service_time)+(q->FCFS_time.finish_time);// 服务时间p->FCFS_time.turnaround_time=(p->FCFS_time.finish_time)-(p->arrive_time);// 周转时间p->FCFS_time.weigtharound_time=(float)(p->FCFS_time.turnaround_time)/(p->service_time);// 带权周转时间}else{p->FCFS_time.finish_time=p->service_time+p->arrive_time;// 服务时间p->FCFS_time.turnaround_time=(p->FCFS_time.finish_time)-(p->arrive_time);// 周转时间p->FCFS_time.weigtharound_time=(float)(p->FCFS_time.turnaround_time)/(p->service_time);// 带权周转时间}q=p;p=p->next;p=head->next;printf(" ******************************** FCFS ******************************** \n");// 输出先到先服务调度后的进程信息printf("\n");printf(" 进程名称"); printf(" 到达时间"); printf(" 服务时间");printf(" 优先级");printf(" 完成时间");printf(" 周转时间"); printf(" 带权周转时间");printf("\n");while(p){printf(" %c ",p->name);printf(" %d ",p->arrive_time);printf(" %d ",p->service_time);printf(" %d ",p->priority);printf(" %d",p->FCFS_time.finish_time);printf(" %d",p->FCFS_time.turnaround_time);printf(" %0.2f",p->FCFS_time.weigtharound_time); printf("\n");p=p->next;}printf("\n");printf(" ********************************************************************** \n");printf("\n");return head;Linklist SJF_scheduling(Linklist head)// 短作业优先算法{Linklist p,r;Linklist q;// 指向前一进程结点int num=0;// 记录进程个数int add_flag=0;// 进程完成服务个数int service_time_min;int arrive_time;int k;p=head->next;// 首元结点while(p) // 初始化进程的完成时间、周转时间、带权周转时间，初值均赋为0{p->SJF_time.finish_time=0; p->SJF_time.turnaround_time=0; p->SJF_time.weigtharound_time=0;p->SJF_time.flag=0;++num;q=p;p=p->next;}q->next=head->next;// 将创建的进程队列变为循环队列p=head->next;q=p;p->SJF_time.finish_time=p->arrive_time+p->service_time;p->SJF_time.turnaround_time=(p->SJF_time.finish_time)-(p->arrive_time);// 周转时间p->SJF_time.weigtharound_time=(float)(p->SJF_time.turnaround_time)/(p->service_time);// 带权周转时间q->SJF_time.finish_time=p->SJF_time.finish_time;p->SJF_time.flag=1; add_flag=1;p=p->next;do{ if(p->SJF_time.flag==1){p=p->next;} else if((p->arrive_time)>(q->SJF_time.finish_time)) {service_time_min=p->service_time;arrive_time=p->arrive_time;while(p->arrive_time==arrive_time&&p->SJF_time.flag==0)// 寻找最短的作业{if((p->next->service_time)<(p->service_time)){service_time_min=p->next->service_time;p=p->next;}else {p=p->next;}}p=q->next;r=q;while(p->service_time!=service_time_min){p=p->next;}// 指针指向最短作业p->SJF_time.finish_time=p->arrive_time+p->service_time;p->SJF_time.flag=1;++add_flag;p->SJF_time.turnaround_time=(p->SJF_time.finish_time)-(p->arrive_time);// 周转时间p->SJF_time.weigtharound_time=(float)(p->SJF_time.turnaround_time)/(p->service_time);// 带权周转时间q=p;p=r->next;}else{k=0;service_time_min=p->service_time;while(((p->arrive_time)<=(q->SJF_time.finish_time))&&k<=num)// 寻找最短的作业{if(p->SJF_time.flag==1) {p=p->next;++k;}else if((p->SJF_time.flag!=1)&&((p->service_time)<service_time_min)){ service_time_min=p->service_time;p=p->next;++k;}else { p=p->next;++k; }}p=q->next;r=q;while(p->service_time!=service_time_min){p=p->next;}// 指针指向最短作业p->SJF_time.finish_time=q->SJF_time.finish_time+p->service_time;p->SJF_time.turnaround_time=(p->SJF_time.finish_time)-(p->arrive_time);// 周转时间p->SJF_time.weigtharound_time=(float)(p->SJF_time.turnaround_time)/(p->service_time);// 带权周转时间p->SJF_time.flag=1;++add_flag;//q=p;p=p->next;q=p;p=r->next;}}while(add_flag!=num);for(p=head->next;num>0;num--)// 断开循环队列{ q=p;p=p->next;} q->next=NULL;p=head->next;// 指向链首，输出短作业调度后的进程信息printf("\n");printf(" ******************************** SJF ********************************* \n");printf("\n");printf(" 进程名称");printf(" 到达时间"); printf("服务时间"); printf(" 优先级");printf(" 完成时间");printf(" 周转时间"); printf("printf("\n");带权周转时间while(p){printf(" %c ",p->name);printf(" %d ",p->arrive_time);printf(" %d ",p->service_time);printf(" %d ",p->priority);printf(" %d",p->SJF_time.finish_time);printf(" %d",p->SJF_time.turnaround_time);printf(" %0.2f",p->SJF_time.weigtharound_time);printf("\n");p=p->next;}printf("\n");printf(" ********************************************************************** \n");printf("\n");return head;Linklist RR_scheduling(Linklist head)// 时间片轮转算法{Linklist q;// 指向前一进程结点Linklist p;int q_time;// 时间片大小int num=0;// 记录进程个数int add_flag=0;// 进程完成服务个数printf(" 请输入时间片的大小 : "); scanf("%d",&q_time);p=head->next;while(p) // 初始化进程的完成时间、周转时间、带权周转时间，初值均赋为 0 {p->RR_time.finish_time=0; p->RR_time.turnaround_time=0;p->RR_time.weigtharound_time=0; p->RR_time.flag_time=p->service_time;q=p;++num;p=p->next;}q->next=head->next;// 将创建的进程队列变为循环队列 p=head->next;q->RR_time.finish_time=p->arrive_time;do{/* printf("\n"); if((p->RR_time.flag_time)>(q_time))// 服务时间大于时间片{ p->RR_time.finish_time=(q->RR_time.finish_time)+(q_time);// 累加完成时间p->RR_time.flag_time=(p->RR_time.flag_time)-(q_time);if((p->next->arrive_time)<=(p->RR_time.finish_time))// 有进程等待{ q=p;p=p->next; }else // 当前进程未完成，无进程等待，指针不向后移{ q=p; }}else if((p->RR_time.flag_time)==0)// 进程已经完成{p=p->next;}else{ printf("%c ",p->name); printf("printf("printf("%d ",p->arrive_time); %d ",p->service_time); %d ",p->priority); printf("%d",p->RR_time.finish_time);printf("printf("\n"); */************************************************************** \n");p->RR_time.finish_time=(q->RR_time.finish_time)+(p->RR_time.flag_time);p->RR_time.flag_time=0; ++add_flag;p->RR_time.turnaround_time=(p->RR_time.finish_time)-(p->arrive_time);// 周转时间p->RR_time.weigtharound_time=(float)(p->RR_time.turnaround_time)/(p->service_time);// 带权周转时间if((p->next->arrive_time)<(p->RR_time.finish_time))// 有进程等待{ q=p;p=p->next; }else // 当前进程完成，无进程等待，指针向后移//{ q=p; q->RR_time.finish_time=p->next->arrive_time; }{p=p->next;q=p;q->RR_time.finish_time=p->arrive_time;}}}while(add_flag!=num);//}while(p->RR_time.flag==0);for(p=head->next;num>0;num--)// 断开循环队列{q=p;p=p->next;} q->next=NULL;p=head->next;// 指向链首，输出时间片轮转调度后的进程信息printf("\n");printf(" ******************************** RR ********************************** \n");printf("\n");printf(" 进程名称"); printf(" 到达时间"); printf(" 服务时间");printf(" 优先级");printf(" 完成时间"); printf(" 周转时间"); printf(" 带权周转时间");printf("\n");while(p){printf(" %c ",p->name);printf(" %d ",p->arrive_time);printf(" %d ",p->service_time);printf(" %d ",p->priority);printf(" %d",p->RR_time.finish_time);printf(" %d",p->RR_time.turnaround_time);printf(" %0.2f",p->RR_time.weigtharound_time);printf("\n");p=p->next;}printf("\n");printf(" ********************************************************************** \n");printf("\n");return head;}Linklist Pri_scheduling(Linklist head)// 优先权调度算法printf(" 优先权调度算法\n"); return head;}。