作业调度算法先来先服务算法短作业算法Word文件下载.docx

作业调度算法先来先服务算法短作业算法Word文件下载.docx

《作业调度算法先来先服务算法短作业算法Word文件下载.docx》由会员分享，可在线阅读，更多相关《作业调度算法先来先服务算法短作业算法Word文件下载.docx（23页珍藏版）》请在冰豆网上搜索。

#include<

stdio.h>

stdlib.h>

time.h>

structwork

{

intid;

intarrive_time;

intwork_time;

intwait;

floatpriority;

};

typedefstructsjf_work

structworks_work;

//数据域

structsjf_work*pNext;

//指针域

}NODE,*PNODE;

voidFCFS（）;

voidSJF（）;

voidshowmenu（）;

boolIs_empty（PNODEpHead）;

intcnt_work（PNODEpHead）;

PNODEdo_work（PNODEpHead,int*w_finish_time,inti）;

voidshow（int*w_finish_time,inti,PNODEq,int*w_rel_time）;

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_tim