#include<iostream.h>
#include<stdio.h>
struct pcb{
char pno
int come_time //到达时间
int run_time //服务时间
}
float fcfs(pcb pro[],int n)
{
struct pcb temp
int i,j,k //time为当前时间
float weight_time=0,time=0 //记录周转时间的和
//temp=(pcb)malloc(sizeof(pcb))
cout<<"进程调度情况如下:"<<endl
cout<<"进程号 到达时间服务时间周转时间:"<<endl
//选择排序过程,按到达时间升序排列
for(i=0i<n-1i++)
{
k=i
for(j=i+1j<nj++)
if(pro[k].come_time>pro[j].come_time)
k=j
if(k!=i)
{
temp=pro[i]
pro[i]=pro[k]
pro[k]=temp
}
}
for(i=0i<ni++)
{ time+=pro[i].run_time
weight_time+=(time-pro[i].come_time)/pro[i].run_time //(time-pro[i].come_time)/pro[i].run_time为排序后第i个进程的周转时间
cout<<pro[i].pno<<" "<<pro[i].come_time<<" "<<pro[i].run_time<<" "<<(time-pro[i].come_time)/pro[i].run_time<<endl
}
return weight_time/=n //返回平均带权周转时间
}
void insert(pcb pro[],pcb pro1,int start,int end)//将一pcb类型的元素插入到有序数组中，最后还保持有序
{
int i=end
while((i--)>start)
if(pro[i].run_time>pro1.run_time)pro[i+1]=pro[i]
pro[i]=pro1
}
float sjp(pcb pro[],int n)
{
int i,first=0,count,flag[20],k,min
float time=0,weight_time=0
//调度第一个到达内存的进程
for(i=1i<ni++)
{
if(pro[first].come_time>pro[i].come_time) first=i
flag[i]=0
}
flag[first]=1
time=(float)pro[first].run_time
weight_time=1
cout<<pro[first].pno<<" "<<pro[first].come_time<<""<<pro[first].run_time<<" "<<weight_time<<endl
//pro_temp[0]=pro[first]
count=n-1
while(count)
{
k=0
min=32767 //设置一个较大的阈值，
for(i=0i<ni++) //找到一个未被访问的，作业较短的且已经到达内存的作业调度
if((i!=first)&&(flag[i]==0)&&(time>=pro[i].come_time)&&(min>pro[i].run_time))
{
k=i
min=pro[i].run_time
}
flag[k]=1 //访问后置标记为访问
time+=pro[k].run_time
weight_time+=(time-pro[k].come_time)/pro[k].run_time
cout<<pro[k].pno<<" "<<pro[k].come_time<<""<<pro[k].run_time<<""<<(time-pro[k].come_time)/pro[k].run_time<<endl
count-- //每调度一个作业，count减1
}
return weight_time/=n
}
void main()
{
pcb pro[5]={{'C',2,5},{'A',0,4},{'B',1,3},{'D',3,2},{'E',4,4}}
cout<<fcfs(pro,5)<<endl
cout<<sjp(pro,5)<<endl
}
真不容易啊，怕是没人弄了!优先级调度算法程序:
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
typedef struct node
{
char name[10] /*进程标识符*/
int prio /*进程优先数*/
int round /*进程时间轮转时间片*/
int cputime/*进程占用CPU时间*/
int needtime/*进程到完成还要的时间*/
int count /*计数器*/
char state/*进程的状态*/
struct node *next/*链指针*/
}PCB
PCB *finish,*ready,*tail,*run/*队列指针*/
int N/*进程数*/
/*将就绪队列中的第一个进程投入运行*/
firstin()
{
run=ready /*就绪队列头指针赋值给运行头指针*/
run->state='R' /*进程状态变为运行态*/
ready=ready->next /*就绪对列头指针后移到下一进程*/
}
/*标题输出函数*/
void prt1(char a)
{
if(toupper(a)=='P') /*优先数法*/
printf(" name cputime needtime priority state\n")
else
printf(" name cputime needtime count round state\n")
}
/*进程PCB输出*/
void prt2(char a,PCB *q)
{
if(toupper(a)=='P') /*优先数法的输出*/
printf(" %-10s%-10d%-10d%-10d %c\n",q->name,
q->cputime,q->needtime,q->prio,q->state)
else/*轮转法的输出*/
printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,
q->cputime,q->needtime,q->count,q->round,q->state)
}
/*输出函数*/
void prt(char algo)
{
PCB *p
prt1(algo) /*输出标题*/
if(run!=NULL) /*如果运行指针不空*/
prt2(algo,run)/*输出当前正在运行的PCB*/
p=ready /*输出就绪队列PCB*/
while(p!=NULL)
{
prt2(algo,p)
p=p->next
}
p=finish /*输出完成队列的PCB*/
while(p!=NULL)
{
prt2(algo,p)
p=p->next
}
getch() /*压任意键继续*/
}
/*优先数的插入算法*/
insert1(PCB *q)
{
PCB *p1,*s,*r
int b
s=q /*待插入的PCB指针*/
p1=ready/*就绪队列头指针*/
r=p1/*r做p1的前驱指针*/
b=1
while((p1!=NULL)&&b) /*根据优先数确定插入位置*/
if(p1->prio>=s->prio)
{
r=p1
p1=p1->next
}
else
b=0
if(r!=p1) /*如果条件成立说明插入在r与p1之间*/
{
r->next=s
s->next=p1
}
else
{
s->next=p1 /*否则插入在就绪队列的头*/
ready=s
}
}
/*轮转法插入函数*/
insert2(PCB *p2)
{
tail->next=p2 /*将新的PCB插入在当前就绪队列的尾*/
tail=p2
p2->next=NULL
}
/*优先数创建初始PCB信息*/
void create1(char alg)
{
PCB *p
int i,time
char na[10]
ready=NULL/*就绪队列头指针*/
finish=NULL /*完成队列头指针*/
run=NULL/*运行队列指针*/
printf("Enter name and time of process\n")/*输入进程标识和所需时间创建PCB*/
for(i=1i<=Ni++)
{
p=malloc(sizeof(PCB))
scanf("%s",na)
scanf("%d",&time)
strcpy(p->name,na)
p->cputime=0
p->needtime=time
p->state='w'
p->prio=50-time
if(ready!=NULL) /*就绪队列不空调用插入函数插入*/
insert1(p)
else
{
p->next=ready/*创建就绪队列的第一个PCB*/
ready=p
}
}
clrscr()
printf(" output of priority:\n")
printf("************************************************\n")
prt(alg) /*输出进程PCB信息*/
run=ready/*将就绪队列的第一个进程投入运行*/
ready=ready->next
run->state='R'
}
/*轮转法创建进程PCB*/
void create2(char alg)
{
PCB *p
int i,time
char na[10]
ready=NULL
finish=NULL
run=NULL
printf("Enter name and time of round process\n")
for(i=1i<=Ni++)
{
p=malloc(sizeof(PCB))
scanf("%s",na)
scanf("%d",&time)
strcpy(p->name,na)
p->cputime=0
p->needtime=time
p->count=0/*计数器*/
p->state='w'
p->round=2 /*时间片*/
if(ready!=NULL)
insert2(p)
else
{
p->next=ready
ready=p
tail=p
}
}
clrscr()
printf(" output of round\n")
printf("************************************************\n")
prt(alg) /*输出进程PCB信息*/
run=ready /*将就绪队列的第一个进程投入运行*/
ready=ready->next
run->state='R'
}
/*优先数调度算法*/
priority(char alg)
{
while(run!=NULL) /*当运行队列不空时，有进程正在运行*/
{
run->cputime=run->cputime+1
run->needtime=run->needtime-1
run->prio=run->prio-3/*每运行一次优先数降低3个单位*/
if(run->needtime==0) /*如所需时间为0将其插入完成队列*/
{
run->next=finish
finish=run
run->state='F' /*置状态为完成态*/
run=NULL /*运行队列头指针为空*/
if(ready!=NULL) /*如就绪队列不空*/
firstin()/*将就绪对列的第一个进程投入运行*/
}
else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/
if((ready!=NULL)&&(run->prio<ready->prio))
{
run->state='W'
insert1(run)
firstin()/*将就绪队列的第一个进程投入运行*/
}
prt(alg)/*输出进程PCB信息*/
}
}
/*时间片轮转法*/
roundrun(char alg)
{
while(run!=NULL)
{
run->cputime=run->cputime+1
run->needtime=run->needtime-1
run->count=run->count+1
if(run->needtime==0)/*运行完将其变为完成态，插入完成队列*/
{
run->next=finish
finish=run
run->state='F'
run=NULL
if(ready!=NULL)
firstin()/*就绪对列不空，将第一个进程投入运行*/
}
else
if(run->count==run->round) /*如果时间片到*/
{
run->count=0 /*计数器置0*/
if(ready!=NULL) /*如就绪队列不空*/
{
run->state='W'/*将进程插入到就绪队列中等待轮转*/
insert2(run)
firstin()/*将就绪对列的第一个进程投入运行*/
}
}
prt(alg)/*输出进程信息*/
}
}
/*主函数*/
main()
{
char algo /*算法标记*/
clrscr()
printf("type the algorithm:P/R(priority/roundrobin)\n")
scanf("%c",&algo)/*输入字符确定算法*/
printf("Enter process number\n")
scanf("%d",&N)/*输入进程数*/
if(algo=='P'||algo=='p')
{
create1(algo)/*优先数法*/
priority(algo)
}
else
if(algo=='R'||algo=='r')
{
create2(algo)/*轮转法*/
roundrun(algo)
}
}
将printf("%s\t%4d\t%4d\t%4d\t%4d\t%4d\t\t%4.2lf\t%4.2lf\n",pro[s].name,pro[s].arrive,pro[s].service,pro[s].wait,pro[s].begin,pro[s].over,pro[s].cycle,pro[s].right)中pro[s]的s改为t.
