轮转rr算法

A. 操作系统时间片轮转算法中，新进程到来时是插入在就绪队列队首还是队尾，为什么

那得看什么情况了 如果是一级 那就到队尾
如果不是一级那就复杂了
比如：我在网上看到的一道题：
设一个系统中有5个进程，他们的到达时间和服务时间如下表所示，忽略I/O以及其他开销时间，若分别按先来先服务（FCFS）、非抢占短进程优先（SPF）、高响应比优先（HRRN）、时间片轮转（RR，时间片=1）、多级反馈队列（FB，第i级队列的时间片=2i-1）调度算法进行CPU调度，请给出各进程的完成时间、周转时间、平均周转时间、带权周转时间、平均带权周转时间

进程 到达时间 服务时间
A 0 3
B 2 6
C 4 4
D 6 5
E 8 2

具体流程：时间片第一级1s，第二级2s，第三级4s...优先级第一级>第二级>第三级...首先A进入第一级执行1s，进入第二级，由于此时B还没有到达，所以A在第二级执行2s，完成，此时是第3s。B第2s已进入第一级，此时回到第一级B执行1s进入第二级，4s的时候c进入第一级，C执行1s进入第二级排在B的后面。此时候为5S，D没有到达，第一级没有进程，所以第二级B执行2S，进入第三级，此时为7S，D已进入第一级，D执行一S，转入第二级排在C后面，8S，E进入第一级，执行一S，进入第二级，排在D后面。第一级没有进程，第二级的C执行2S，进入第三级，D执行2s进入第三级，E执行1S完成，此时是14S。第二级没有进程，由第三级的D开始，执行3S完成，此时是17S，C执行1S完成，此时是18S，D执行2S完成，此时是20S。所以答案是，3，17，18，20，14

B. 操作系统中关于时间片轮转调度算法！大家帮解答下！

时间片第一级1s，第二级2s，第三级4s...优先级第一级>第二级>第三级...首先A进入第一级执行1s，进入第二级，由于此时B还没有到达，所以A在第二级执行2s，完成，此时是第3s。B第2s已进入第一级，此时回到第一级B执行1s进入第二级，4s的时候c进入第一级，C执行1s进入第二级排在B的后面。此时候为5S，D没有到达，第一级没有进程，所以第二级B执行2S，进入第三级，此时为7S，D已进入第一级，D执行一S，转入第二级排在C后面，8S，E进入第一级，执行一S，进入第二级，排在D后面。第一级没有进程，第二级的C执行2S，进入第三级，D执行2s进入第三级，E执行1S完成，此时是14S。第二级没有进程，由第三级的D开始，执行3S完成，此时是17S，C执行1S完成，此时是18S，D执行2S完成，此时是20S。所以答案是，3，17，18，20，14

C. 进程创建；运行进程；基于优先级的调度算法。

让他加内容提供方软件能让他

D. C语言编程实现时间片轮转算法，尽量写得简单易懂，谢谢

#include<stdlib.h>
#define MAX 5 //进程数量
#define RR 2 //时间片大小

/*时间片轮转算法*/

struct pro
{
int num;
int arriveTime;
int burst;
int rt; //记录进程被运行的次数
struct pro *next;
};

int TOTALTIME; //记录所有进程的总时间

//函数声明
struct pro* creatList();
void insert(struct pro *head,struct pro *s);
struct pro* searchByAT(struct pro *head,int AT);
void del(struct pro* p);
int getCount(struct pro *head,int time);
struct pro* searchEnd(struct pro *head);
void move(struct pro *headF,struct pro *headT,int n);

struct pro* creatList() //创建链表，按照进程的到达时间排列,记录所有进程的信息
{
struct pro* head=(struct pro*)malloc(sizeof(struct pro));
head->next=NULL;
struct pro* s;
int i;
TOTALTIME=0;
for(i=0;i<MAX;i++)
{
s=(struct pro*)malloc(sizeof(struct pro));
printf("请输入进程名:\n");
scanf("%d",&(s->num));
printf("请输入到达时间:\n");
scanf("%d",&(s->arriveTime));
printf("请输入运行时间:\n");
scanf("%d",&(s->burst));
TOTALTIME+=s->burst; //计算总时间
s->rt=1; //rt的初始值为1
s->next=NULL;
insert(head,s);
}
return head; //到达队列中的进程按照其到达时间的先后顺序排列
}

void insert(struct pro *head,struct pro *s) //插入节点
{
struct pro *p=searchByAT(head,s->arriveTime);
s->next=p->next;
p->next=s;
return;
}

struct pro* searchByAT(struct pro *head,int AT) //查找第一个到达时间大于等于AT的节点，返回其前一个指针
{
struct pro *p,*q;
p=head;
q=head->next;
while(q!=NULL&&q->arriveTime<=AT)
{
p=q;
q=q->next;
}
return p;
}

void del(struct pro* p) //删除p的下一个节点
{
struct pro *tmp;
tmp=p->next;
p->next=tmp->next;
free(tmp);
return;
}

int getCount(struct pro *head,int time) //察看在time之前到达但未移动到运行队列的进程数量
{
int count=0;
struct pro *s,*t;
s=head;
t=s->next;
while(t!=NULL&&t->arriveTime<=time)
{
s=t;
t=t->next;
count++; //count记录当前时刻到达的进程数
}
return count;
}

struct pro* searchEnd(struct pro *head) //查找并返回循坏队列的尾节点的前一个节点
{
struct pro *p,*q;
p=head;
q=head->next;
while(q->next!=head)
{
p=q;
q=q->next;
}
return p;
}

void move(struct pro *headF,struct pro *headT,int n) //将headF后的n个节点移动到循环队列headT中
{
struct pro *r,*s,*t;
s=headF;
t=s->next;
r=t; //r记录要移动的第一个节点
while(n>1)
{
t=t->next;
n--;
}
s->next=t->next; //以上完成从原队列中摘除相关节点,r,t分别为第一个和最后一个节点
s=searchEnd(headT);
t->next=s->next;
s->next=r;
}

void run(struct pro *head)
{
int time=0; //记录当前时间
int newarrive;//新到达进程数
struct pro *runhead=(struct pro*)malloc(sizeof(struct pro));
runhead->next=runhead; //创建新的循环链表，存放当前就绪队列中的进程
struct pro *p,*q;
p=runhead;
q=p->next; //q记录当前应当运行的进程
while(time<=TOTALTIME)
{
newarrive=getCount(head,time);
if(newarrive>0)
move(head,runhead,newarrive); //将head后的newarrive个节点移动到runhead队列中
if(runhead->next==runhead) //就绪队列中没有进程
time++;
else if(q==runhead)
{
p=q;
q=q->next;
}
else
{
printf("进程名:%d\n",q->num);
printf("到达时间:%d\n",q->arriveTime);
if(q->rt==1)
printf("响应时间:%d\n",time-q->arriveTime);
else
printf("第%d次运行开始时间:%d\n",q->rt,time);
if(q->burst<=RR)
{
time+=q->burst;
printf("第%d次运行结束时间:%d\n",q->rt,time);
printf("周转时间:%d\n",time-q->arriveTime);
printf("************************************\n");
struct pro *tmp=q;
q=q->next;
p->next=q;
free(tmp);
}
else //q->burst>RR
{
time+=RR;
printf("第%d次运行结束时间:%d\n",q->rt,time);
printf("************************************\n");
q->burst-=RR;
q->rt++;
p=q;
q=q->next;
}
}
}
}

void main()
{
struct pro *head=creatList();
printf("当前时间片大小为:%d\n",RR);
run(head);
}

E. 考虑一种RR(时间片轮转)调度算法的变种,算法中就绪队列中存放的是指向各个进程控

#include “stdio.h”
#define running 1 // 用running表示进程处于运行态
#define aready 2 // 用aready表示进程处于就绪态
#define blocking 3 // 用blocking表示进程处于阻塞态
#define sometime 5 // 用sometime表示时间片大小
#define n 10 //假定系统允许进程个数为n
struct
{
int name; //进程标识符
int status; //进程状态
int ax,bx,cx,dx ; //进程现场信息，通用寄存器内容
int pc ; //进程现场信息，程序计数器内容
int psw; //进程现场信息，程序状态字内容
int next; //下一个进程控制块的位置
}pcbarea[n]; //模拟进程控制块区域的数组
int PSW, AX,BX,CX,DX , PC ,TIME ; //模拟寄存器
int run; //定义指向正在运行进程的进程控制块的指针
struct
{
int head;
int tail;
}ready; //定义就绪队列的头指针head和尾指针tail
int pfree; //定义指向空闲进程控制块队列的指针

scheling( ) //进程调度函数
{
int i;
if (ready.head==-1) //空闲进程控制块队列为空，退出
{
printf(“无就绪进程\n”);
return;
}
i=ready.head; //就绪队列头指针赋给i
ready.head=pcbarea[ready.head].next; //就绪队列头指针后移
if(ready.head==-1) ready.tail=-1; //就绪队列为空，修正尾指针ready.tail
pcbarea[i].status=running; //修改进程控制块状态
TIME=sometime; //设置相对时钟寄存器
//恢复该进程现场信息
AX=pcbarea[run].ax;
BX=pcbarea[run].bx;
CX=pcbarea[run].cx;
DX=pcbarea[run].dx;
PC=pcbarea[run].pc;
PSW=pcbarea[run].psw;
run=i;
}//进程调度函数结束

create(int x) //进程创建函数
{
int i;
if(pfree==-1) //空闲进程控制块队列为空
{
printf(“无空闲进程控制块，进程创建失败\n”);
return;
}
i=pfree; //取空闲进程控制块队列的第一个
pfree=pcbarea[pfree].next; // pfree后移
//填写该进程控制块的内容
pcbarea[i].name=x;
pcbarea[i].status=aready;
pcbarea[i].ax=x;
pcbarea[i].bx=x;
pcbarea[i].cx=x;
pcbarea[i].dx=x;
pcbarea[i].pc=x;
pcbarea[i].psw=x;
if (ready.head!=-1) //就绪队列不为空时，挂入就绪队列的方式
{
pcbarea[ready.tail].next=i;
ready.tail=i;
pcbarea[ready.tail].next=-1;
}
else //就绪队列为空时，挂入就绪队列的方式
{
ready.head=i;
ready.tail=i;
pcbarea[ready.tail].next=-1;
}
}//进程创建函数结束

main()
{ //系统初始化
int num,i,j;
run=ready.head=ready.tail =-1;
pfree=0;
for(j=0;j<n-1;j++)
pcbarea[j].next=j+1;
pcbarea[n-1].next=-1;
printf(“输入进程编号（避免编号冲突，以负数输入结束，最多可以创建10个进程）：\n”);
scanf(“%d”,num);
while(num>=0)
{
create(num) ;
scanf(“%d”,num) ;
}
scheling(); //进程调度
if(run!=-1)
{
printf(“进程标识符 进程状态 寄存器内容：ax bx cx dx pc psw:\n”);
printf(“%8d%10d%3d%3d%3d%3d%3d%3d\n”, pcbarea[run].name, pcbarea[run].status, pcbarea[run].ax, pcbarea[run].bx, pcbarea[run].cx, pcbarea[run].dx, pcbarea[run].pc, pcbarea[run].psw);
}
}//main()结束
我用的是vc++6.0的，你可以试试，有不懂得在和我交流吧

F. 在时间片轮转调度中,如果一个进程在一个时间片内就已经运行结束,那剩下的时间片时间怎么利用

如果进程在时间片结束前阻塞或结束，则CPU当即进行切换。结束的进程会从运行队列中清除，剩下的时间片随进程结构的清除而清除，并不影响到其他进程的调度。

时间片由操作系统内核的调度程序分配给每个进程。首先，内核会给每个进程分配相等的初始时间片，然后每个进程轮番地执行相应的时间，当所有进程都处于时间片耗尽的状态时，内核会重新为每个进程计算并分配时间片，如此往复。

在每个进程的task_struct结构中有以下四项：policy、priority、counter、rt_priority。这四项是选择进程的依据。其中，policy是进程的调度策略，用来区分实时进程和普通进程，实时进程优先于普通进程运行；priority是进程(包括实时和普通)的静态优先级。

counter是进程剩余的时间片，它的起始值就是priority的值；由于counter在后面计算一个处于可运行状态的进程值得运行的程度goodness时起重要作用，因此，counter也可以看作是进程的动态优先级。rt_priority是实时进程特有的，用于实时进程间的选择。

(6)轮转rr算法扩展阅读：

时间片长度的影响：

时间片轮转调度中特别需要关注的是时间片的长度。从一个进程切换到另一个进程是需要一定时间的--保存和装入寄存器值及内存映像，更新各种表格和队列等。

假如进程切换(process switch) - 有时称为上下文切换(context switch)，需要5毫秒，再假设时间片设为20毫秒，则在做完20毫秒有用的工作之后，CPU将花费5毫秒来进行进程切换。CPU时间的20%被浪费在了管理开销上。

为了提高CPU效率，我们可以将时间片设为500毫秒。假设所有其他进程都用足它们的时间片的话，最后一个不幸的进程不得不等待5秒钟才获得运行机会。多数用户无法忍受一条简短命令要5秒钟才能做出响应。同样的问题在一台支持多道程序的个人计算机上也会发生。

结论可以归结如下：时间片设得太短会导致过多的进程切换，降低了CPU效率；而设得太长又可能引起对短的交互请求的响应变差。

G. 时间片轮转算法（RR）能不能用在作业调度上还是只能用在进程调度上

导师给出的答案是不能，但是吧友似乎有一些别的看法。
先来看作业调度的定义，高级调度又称长程调度或作业调度，他的调度对象是作业。主要功能是根据算法，决定将外存处于后备队列的哪几个作业调入内存，为他们创建进程，分配必要的资源，并将它们放入就绪队列。分时和实时系统不设置高级调度。
其次简单的叙述一下低级调度（进程调度）：对象为进程，功能是决定就绪队列中的哪个进程应获得处理机，并分配。
最后来看一下RR的核心，进程切换：在RR调度算法中，应在合适进行进程的切换，可分为两种情况：1，若一个时间片尚未用完，正在运行的进程便已经完成，立刻激活调度程序，将他从就绪队列中删除，再调度就绪队列中对手的进程运行，并启动一个新的时间片。2.在一个时间片用完时，计时调度器中断处理程序被激活。如果进程尚未运行完毕，调度程序将把它送往就绪队列的末尾。
可见，RR算法在切换进程时只涉及了就绪队列的c、a、o作，也就是只有低级调度参与，并没有从外存将作业调入内存，另外，RR算法常用于分时系统，分时系统也是不设置作业调度的。

H. 云计算：资源调度管理的目录

第1章 云计算概述
1.1 云计算发展背景
1.2 云计算是集大成者
1.3 为什么需要云计算？
1.4 云计算发展现状和趋势
1.5 云计算应用初步分类
1.6 云计算的产业链中的不同角色
1.7 云计算主要特征和技术挑战
1.8 小结
思考题
参考文献
第2章 云数据中心概述
2.1 云数据中心概述
2.1.1 云数据中心介绍
2.1.2 云数据中心的需求和挑战
2.2 云计算数据中心资源调度需求分析
2.2.1 技术需求
2.2.2 技术目标
2.3 云计算数据中心资源调度研究进展
2.4 云计算数据中心资源调度方案分析
2.4.1 goosle解决方案
2.4.2 amazon解决方案
2.4.3 1bm解决方案
2.4.4 hp解决方案
2.4.5 vmware解决方案
2.4.6 其他厂家解决方案
2.5 云计算数据中心资源调度标准进展
2.6 云计算数据中心资源调度关键技术及研究热点
2.7 小结
思考题
参考文献
第3章 云资源定义与建模
3.1 引言
3.2 云数据中心资源建模
3.2.1 云数据中心多级体系结构
3.2.2 云数据中心涉及的资源
3.3 云数据中心资源定义
3.4 资源管理
3.5 小结
思考题
参考文献
第4章 云资源管理
4.1 概述
4.1.1 面向基础设施搭建的管理软件
4.1.2 面向能效设备控制的管理软件
4.1.3 面向虚拟化的数据中心管理软件
4.2 云数据中心资源管理的内容
4.2.1 用户管理
4.2.2 任务管理
4.2.3 资源管理
4.3 资源管理的目标
4.3.1 自动化
4.3.2 资源优化
4.3.3 简洁管理
4.3.4 虚拟资源与物理资源的整合
4.4 资源管理的关键问题
4.4.1 动态多层次分布式资源监控
4.4.2 物理和虚拟资源动态调度
4.4.3 物理和虚拟资源动态快速部署与维护
4.5 数据中心管理系统案例分析
4.6 小结
思考题
参考文献
第5章 云资源调度策略
5.1 资源调度关键技术
5.2 云计算数据中心调度策略对比分析
5.2.1 amazon调度策略
5.2.2 1bm调度策略
5.2.3 hp调度策略
5.2.4 vmware调度策略
5.2.5 其他方案
5.3 主要调度策略分类
5.3.1 性能优先
5.3.2 成本优先
5.4 调度策略约束条件
5.5 调度任务执行时间和触发条件
5.6 小结
附：基本术语
思考题
参考文献
第6章 云资源负载均衡调度算法的分析与设计
6.1 云计算数据中心综合负载均衡调度策略概述
6.2 云计算数据中心负载均衡调度策略中主要调度算法分析
6.2.1 轮转调度算法(rr)
6.2.2 加权轮转调度算法(wrr)
6.2.3 目标地址哈希调度算法(dh)
6.2.4 源地址哈希调度算法(sh)
6.2.5 最小链接算法(lc)
6.2.6 加权最小链接算法(wlc)
6.3 几种动态综合负载均衡调度算法分析
6.3.1 综合利用率乘积法
6.3.2 综合负载基准对比法
6.3.3 动态反馈综合负载均衡调度算法
6.4 负载均衡调度算法对比
6.5 动态反馈综合负载均衡调度算法详细设计
6.5.1 优化目标
6.5.2 动态反馈综合负载均衡调度算法
6.6 小结
思考题
参考文献
第7章 云数据中心资源调度模拟系统
7.1 简介
7.2 现有系统分析
7.2.1 cloudsim
7.2.2 cloudanalyst
7.3 cloudsched模拟系统设计框架
7.4 模拟系统分析——以考虑需求特性的调度算法为例
7.4.1 考虑需求特性调度算法解决的问题
7.4.2 考虑需求特性调度算法主要步骤
7.4.3 考虑需求特性调度算法流程图
7.4.4 考虑需求特性调度算法伪代码
7.4.5 算法类图
7.4.6 算法时序图
7.5 各种算法结果分析
7.5.1 其他算法思想简介
7.5.2 4种算法数据中心不均衡度对比
7.5.3 4种算法物理服务器不均衡度对比
7.5.4 4种算法运行时间对比
7.6 小结
思考题
参考文献
第8章 总结与展望
附录i 虚拟服务器管理系统vmmanager
附i.1 简介
附i.2 体系结构
附i.3 用户界面设计
附i.4 安装与配置
附i.5 vmmanager使用说明
附录ii 云计算模拟分析器cloudanalyst
附ii.1 cloudanalyst的安装过程
附ii.2 cloudanalyst的运行过程及配量方法

I. 处理机调度可以分为

在多道程序设计系统中，内存中有多道程序运行，他们相互争夺处理机这一重要的资源。处理机调度就是从就绪队列中，按照一定的算法选择一个进程并将处理机分配给它运行，以实现进程并发地执行。
1.处理机调度的功能
一般情况下，当占用处理机的进程因为某种请求得不到满足二不得不放弃CPU进入等待状态时，或者当时间片到，系统不得不将CPU分配给就绪队列中另以进程的时候，都要引起处理机调度。除此之外，进程正常结束、中断处理等也可能引起处理机的调度。因此，处理机调度是操作系统核心的重要组成部分，它的主要功能如下：
（1）记住进程的状态，如进程名称、指令计数器、程序状态寄存器以及所有通用寄存器等现场信息，将这些信息记录在相应的进程控制块中。
（2）根据一定的算法，决定哪个进程能获得处理机，以及占用多长时间。
（3）收回处理机，即正在执行的进程因为时间片用完或因为某种原因不能再执行的时候，保存该进程的现场，并收回处理机。
处理机调度的功能中，很重要的一项就是根据一定算法，从就绪队列中选出一个进程占用CPU运行。可见，算法是处理机调度的关键。
2.处理机调度的性能准则
处理机调度，有许多不问的调度算法，不同的调度算法具有不同的特性。因此，再介绍算法之前，先介绍衡量一个算法的基本准则。
衡量喝比较调度算法性能优劣主要有一下几个因素：
（1）CPU利用率。CPU是计算机系统中最重要的资源，所以应尽可能使CPU保持忙，使这一资源利用率最高。
（2）吞吐量。CPU运行时表示系统正处于工作状态，工作量的大小是以每单位时间所完成的昨夜树木来描述的，这就叫吞吐量。
（3）周转时间。指从作业提交到作业完成所经过的时间，包括作业等待，在就绪队列中排队，在处理机上运行以及进行输入/输出操作所花时间的总和。
（4）等待时间。处理机调度算法实际上并不影响作业执行或输入/输出操作的时间，只影响作业在就绪队列中等待所花的时间。因此，衡量一个调度算法优劣常常简单的考察等待时间。
（5）响应时间。指从作业提交到系统作出相应所经过的时间。在交互式系统中，作业的周转时间并不一定是最好的衡量准则，因此，常常使用另一种度量准则，即相应时间。从用户观点看，相应时间应该快一点好，但这常常要牺牲系统资源利用率为代价。
3.处理机调度算法
1）先来先服调度算法（FIFO）
这是最简单的处理机调度算法，其基本思想是按照进程进入就绪队列的先后顺序调度并分配处理机执行。先来先服务调度算法是一种不可抢占的算法，先进入就绪队列的进程，先费培处理机运行。一旦一个进程占有了处理机，它就一直运行下去，知道该进程完成工作或者因为等待某事件而不能继续运行时才释放处理机。
从表面上看，FIFO算法对所有作业都是公平的，并且一个作业的等待时间时可能预先估计的。但实际上这种算法是不利于小作业的，因为当一个大作业先进入就绪队列时，就会使其后的许多小作业等待很长的时间。这对小作业来说，等待时间可能要远远超出它运行的时间。
先来先服算法简单，易于程序实现，但它性能较差，在实际运行的操作系统中，很少单独使用，它常常配合其他调度算法一起使用。
2）时间片轮转调度算法（RR）
时间片轮转调度算法的基本思想是：对就绪队列中的每一进程部分配一个时间片，时间片的长度q一般从10ms-1100ms不等。把就绪队列堪称时一个环状结构，调度程序按时间片长度q轮流电镀就绪队列中的每一进程，使每一进程都有机会获得相同长度的时间占用处理机运行。
时间片轮转调度算法在分时系统中，时一种既简单又有效的调度策略。一个分时系统又许多中断。中断用户在各自的中断设备上同时使用计算机。如果某个中断用户的程序长时间的暂用处理机，那么其他中断用户的请求就不能得到即使相应。一般说来，中断用户提出请求后，能在几秒钟内得到相应也就感到满意了。采用时间片轮转算法，可以使系统即使的相应各中断用户的请求。
时间片轮转调度算法的性能极大的以来于时间片长度q的取值，如果时间片过大。则RR算法就退化为FIFO算法了；反之，如果时间片过小，那么，处理机在各进程之间频繁转接，处理机时间开销变得很大，而提供给用户程序的时间将大大减少。

J. 模拟短作业优先算法、时间片轮转算法（RR）和优先数算法的执行情况

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#define LENsizeof(struct job)

struct job
{
char name[2];
int cometime;
int runtime;
int priority;
int finishtime;
int state;
struct job *next;
};

void readtxt();
void SJF();
void (structjob *,struct job *);
void RR(int);
void FPF();
void print1(structjob *);
void print2(structjob *);

int n=0;
struct job*head=NULL;
struct job*end=NULL;
FILE*fp=NULL;

void main()
{
if((fp=fopen("JOB1.txt","rb"))==NULL){
printf("can not find file\n");
exit(0);
}
while(!feof(fp)){
readtxt();
}
fclose(fp);

int x,y;
printf("请选择进程调度算法：\n");
printf("1.短作业优先算法 2.时间片轮转算法 3.优先数算法\n");
printf("选择序号：");
scanf("%d",&x);
if((x!=1)&&(x!=2)&&(x!=3))printf("序号不存在！\n");
else{
switch(x){
case 1: SJF(); break;
case 2: {
printf("输入时间片：");
scanf("%d",&y);
RR(y);
break;
}
case 3: FPF(); break;
}
}
}

void readtxt(){
struct job *p1;
p1=(struct job *)malloc(LEN);
fscanf(fp,"%s %d %d%d",(*p1).name,&((*p1).cometime),&((*p1).runtime),&((*p1).priority));
(*p1).state=0;
(*p1).finishtime=0;
if(n==0){
head=p1;
end=p1;
(*end).next=NULL;
n++;
}
else{
(*end).next=p1;
end=p1;
(*end).next=NULL;
n++;
}
}

void SJF(){
struct job *shead,*send,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).runtime<(*p1).runtime)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
shead=p;
send=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).runtime<(*p1).runtime)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*send).next=p;
send=p;
}
(*send).next=NULL;
printf("%s\n","短作业优先算法执行结果：");
printf("%s\n","进程执行顺序 周转时间");
print1(shead);
}

void RR(intpertime){
structjob *rhead,*rend,*rrhead,*rrend,*p1,*p2,*p;
int i,curtime=0,m=0,temp1=0,temp2;
while(m!=n){
p1=head;
temp2=temp1;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).runtime!=0)&&((*p1).state!=1)){temp1++;break;}
else p1=(*p1).next;
}
if(p1!=NULL){
p2=(*p1).next;
for(i=i+1;i<n;i++){
if((((*p2).cometime<(*p1).cometime)&&((*p2).runtime!=0)&&((*p2).state!=1))||
(((*p2).cometime==(*p1).cometime)&&((*p2).priority<(*p1).priority)&&((*p2).runtime!=0)&&((*p2).state!=1)))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
}

if(temp2!=temp1){
(*p1).state=1;
p=(struct job *)malloc(LEN);
(p,p1);
if(temp1==1) {rhead=p;rend=p;}
else{
(*rend).next=p;
rend=(*rend).next;
}
}
else{
if((temp1==1)&&(m==0)){
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
}
p=(struct job *)malloc(LEN);
(p,rhead);
rrhead=p;
rrend=p;
}
else{
if(strcmp((*rhead).name,(*rrend).name)==0){
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}

}
else{
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}
}
}
}
}
(*rrend).next=NULL;
printf("%s%d%s\n","时间片轮转算法执行结果(时间片",pertime,")：");
print2(rrhead);
}

void FPF(){
structjob *fhead,*fend,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).priority<(*p1).priority)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
fhead=p;
fend=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).priority<(*p1).priority)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*fend).next=p;
fend=p;
}
(*fend).next=NULL;
printf("%s\n","最高优先权优先算法执行结果(非抢占方式)：");
printf("%s\n","进程执行顺序 周转时间");
print1(fhead);
}

void (structjob *p,struct job *p1){
strcpy((*p).name,(*p1).name);
(*p).cometime=(*p1).cometime;
(*p).runtime=(*p1).runtime;
(*p).priority=(*p1).priority;
(*p).finishtime=(*p1).finishtime;
(*p).state=(*p1).state;
}

void print1(structjob *p){
while(p!=NULL){
printf("%-14s%d\n",(*p).name,(*p).finishtime-(*p).cometime);
p=(*p).next;
}
}

void print2(structjob *p){
struct job *head;
head=p;
printf("%s\n","进程执行顺序");
while(head!=NULL){
printf("%3s",(*head).name);
head=(*head).next;
}
printf("\n%s\n","进程周转时间");
head=p;
while(head!=NULL){
if(((*head).finishtime-(*head).cometime)>0)
printf("%-4s%d\n",(*head).name,(*head).finishtime-(*head).cometime);
head=(*head).next;
}
}

网上找的，自己看着办