作业调度算法先来先服务算法短作业算法Word下载.docx
《作业调度算法先来先服务算法短作业算法Word下载.docx》由会员分享，可在线阅读，更多相关《作业调度算法先来先服务算法短作业算法Word下载.docx（23页珍藏版）》请在冰豆网上搜索。
voidHRRN（）;
PNODEpriorit（PNODEpHead）;
voiddo_work_1（PNODEpHead,int*w_finish_time,inti）;
intmain（）
intchoice;
//设置选择数
showmenu（）;
//显示菜单
scanf（"
%d"
&
choice）;
while（choice!
=0）//选择算法
{
switch（choice）
{
case1:
printf（"
您选择的是先来先服务算法:
\n"
）;
FCFS（）;
break;
case2:
您选择的是短作业优先算法:
SJF（）;
case3:
您选择的是高响应比优先调度算法\n"
HRRN（）;
default:
请重新选择！
"
}
printf（"
下面是菜单，请继续，或者按‘0’退出"
showmenu（）;
scanf（"
}
printf（"
感谢您使用本系统，再见！
return0;
}
voidFCFS（）
intj,k;
intw_rel_time[5];
intw_finish_time[5];
floatrel_time=0;
structworktemp;
inti;
structworkw[5];
srand（time（0））;
for（i=0;
i<
5;
i++）
w[i].id=rand（）%10;
w[i].arrive_time=rand（）%10;
w[i].work_time=rand（）%10+1;
for（j=0;
j<
j++）
第%d个作业的编号是：
%d\t"
j+1,w[j].id）;
第%d个作业到达时间：
j+1,w[j].arrive_time）;
第%d个作业服务时间：
j+1,w[j].work_time）;
for（j=1;
for（k=0;
k<
5-j;
k++）
if（w[k].arrive_time>
w[k+1].arrive_time）
{
temp=w[k];
w[k]=w[k+1];
w[k+1]=temp;
}
w_finish_time[0]=w[0].arrive_time+w[0].work_time;
for（j=0;
if（w_finish_time[j]<
w[j+1].arrive_time）
w_finish_time[j+1]=w[j+1].arrive_time+w[j+1].work_time;
else
w_finish_time[j+1]=w_finish_time[j]+w[j+1].work_time;
w_rel_time[j]=w_finish_time[j]-w[j].arrive_time;
rel_time+=w_rel_time[j];
printf（"
第%d个系统执行的作业到达时间：
%d"
编号是：
w[j].id）;
服务时间是：
w[j].work_time）;
完成时间是：
w_finish_time[j]）;
周转时间是：
w_rel_time[j]）;
平均周转时间：
%f\n"
rel_time/5）;
voidSJF（）
intw_rel_time[10];
intw_finish_time[10];
intj=0;
PNODEpHead=（PNODE）malloc（sizeof（NODE））;
if（NULL==pHead）
分配失败,程序终止!
exit（-1）;
PNODEpTail=pHead;
pTail->
pNext=NULL;
//定义该链表有头结点，且第一个节点初始化为空
10;
PNODEpNew=（PNODE）malloc（sizeof（NODE））;
if（NULL==pNew）
exit（-1）;
pNew->
s_work.id=rand（）%100;
s_work.arrive_time=rand（）%10;
s_work.work_time=rand（）%10+1;
pTail->
pNext=pNew;
pTail=pNew;
PNODEp=pHead->
pNext;
//p指向第一个节点
while（NULL!
=p）
j+1,p->
s_work.id）;
s_work.arrive_time）;
s_work.work_time）;
p=p->
j++;
p=pHead->
PNODEq=p;
//p,q都指向第一个节点
p=p->
while（p!
=NULL）
if（p->
s_work.arrive_time<
q->
s_work.arrive_time）
q=p;
PNODEr=pHead->
//r也指向第一个节点
intcnt=0;
//记录所有节点数据域中到达时间最短且相等的个数
while（r!
if（r->
s_work.arrive_time==q->
s_work.arrive_time）
cnt++;
r=r->
=NULL）//在相等到达时间的作业中找服务时间最短的作业
if（cnt>
1）
if（p->
if（p->
s_work.work_time<
s_work.work_time）
q=p;
p=p->
else
p=NULL;
}//确定q所指作业最先到达且服务时间最短
w_finish_time[0]=q->
s_work.arrive_time+q->
s_work.work_time;
w_rel_time[0]=w_finish_time[0]-q->
s_work.arrive_time;
第1个系统执行的作业到达时间：
q->
%d\n"
w_finish_time[0]）;
w_rel_time[0]）;
p=pHead;
//寻找q的前一个节点，方便删掉q节点
while（p->
pNext!
=q）
}
p->
pNext=q->
free（q）;
q=NULL;
9&
&
!
Is_empty（pHead）;
{
现在系统还剩%d个作业！
cnt_work（pHead））;
q=do_work（pHead,w_finish_time,i）;
show（w_finish_time,i,q,w_rel_time）;
p=pHead;
while（p->
p=p->
}
p->
free（q）;
q=NULL;
rel_time+=w_rel_time[j];
rel_time/10）;
boolIs_empty（PNODEpHead）//判断作业是否做完
PNODEp;
intlen=0;
len++;
if（len==0）
returntrue;
//当没有作业时，返回为真
else
returnfalse;
intcnt_work（PNODEpHead）//计算当前还剩多少作业
returnlen;
PNODEdo_work（PNODEpHead,int*w_finish_time,inti）
PNODEp,q;
//计数器清0，计算当前作业完成时，系统中有多少个作业已经到达
=NULL）
if（p->
=w_finish_time[i]）
cnt++;
q=p;
}//q指向当前到达时间小于刚刚完成的作业，但不一定是服务时间最短的（如果有的话）
系统中有%d个作业在当前作业完成时已经到达！
cnt）;
if（cnt>
1）//执行此次判断后，q现在指向所有条件都满足的作业（如果有的话）
{
q=p;
p=p->
}
else
else//当前作业完成时，没有作业到达的情况
//用q来接收最先到达的，用p来遍历
while（p!
=NULL）
s_work.arrive_time<
w_finish_time[i+1]=q->
w_finish_time[i+1]=w_finish_time[i]+q->
returnq;
voidshow（int*w_finish_time,inti,PNODEq,int*w_rel_time）
w_rel_time[i+1]=w_finish_time[i+1]-q->
i+2,q->
%d\n"
w_finish_time[i+1]）;
w_rel_time[i+1]）;
voidshowmenu（）
**********************************\n"
请选择你要执行的命令~:
\n"
1：
先来先服务算法\n"
2：
短作业优先算法\n"
3:
高响应比优先算法\n"
0:
退出菜单\n"
voidHRRN（）
//计算优先权
i++）//定义了十个进程
//已经找到并执行第一个进程，执行完之后又将其删除了
do_work_1（pHead,w_finish_time,i）;
q=priorit（pHead）;
voiddo_work_1（PNODEpHead,int*w_finish_time,inti）
}//q指向当前到达时间小于刚刚完成的作业，但有可能有另外几个进程也已经到达了，所以要进行下面的判断
pNe
升级会员 