本文目录一览：
- 1、编写代码实现作业的三种调度算法
- 2、短作业优先算法用c语言如何写?
- 3、求一份儿C语言优先级调度算法要求如下
- 4、操作系统的作业，用C语言模拟先来先服务的方法的进程调度，请大神帮忙看看我这个代码有什么问题
- 5、求进程调度先来先服务算法，短进程优先算法完整c语言代码
- 6、急求 程序代码 c/c++ 操作系统中的 处理机调度算法
编写代码实现作业的三种调度算法
#includewindows.h
#includeiostream
#includestdio.h
#includestring
using namespace std;
const int maxnum=100;
int N; /*进程数*/
double start[maxnum],endtime[maxnum],arrive[maxnum],runtime[maxnum],zhou[maxnum];
double averagezhou; // 平均周转时间
double average_zhou; //平均带权周转时间
char name; //进程名
double dqzhou[maxnum]; //带权周转时间
typedef struct node
{
char name[10]; //进程名
int round; //进程时间轮转时间片
int cputime; //进程占用CPU时间
int needtime; //进程到完成还要的时间
char state; //进程的状态
struct node *next; //链指针
}PCB;
PCB *finish,*ready,*tail,*run; /*队列指针*/
void firstin() /*将就绪队列中的第一个进程投入运行*/
{
run=ready; /*就绪队列头指针赋值给运行头指针*/
run-state='R'; /*进程状态变为运行态*/
ready=ready-next; /*就绪对列头指针后移到下一进程*/
}
void print1(PCB *q) /*进程PCB输出*/
{
printf("进程名 已运行时间 还需要时间 时间片 状态\n");
printf(" %-10s%-15d%-10d%-10d %-c\n",q-name,q-cputime,q-needtime,q-round,q-state);
}
void print() /*输出函数*/
{
PCB *p;
if(run!=NULL) /*如果运行指针不空*/
print1(run); /*输出当前正在运行的PCB*/
p=ready; /*输出就绪队列PCB*/
while(p!=NULL)
{
print1(p);
p=p-next;
}
p=finish; /*输出完成队列的PCB*/
while(p!=NULL)
{
print1(p);
p=p-next;
}
}
void insert(PCB *p2) //轮转法插入函数
{
tail-next=p2; //将新的PCB插入在当前就绪队列的尾
tail=p2;
p2-next=NULL;
}
void create() /*创建进程PCB*/
{
PCB *p;
int i,time;
char na[10];
ready=NULL;
finish=NULL;
run=NULL;
printf("请输入进程名称和所需要CPU的时间:\n");
for(i=1;i=N;i++)
{
p=(PCB *)malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",time);
strcpy(p-name,na);
p-cputime=0;
p-needtime=time;
if(i==1)
p-state='R';
else
p-state='W';
p-round=1; /*时间片*/
if(ready!=NULL)
insert(p);
else
{
p-next=ready;
ready=p;
tail=p;
}
}
printf("------------------------------------------------------------------\n");
print(); /*输出进程PCB信息*/
run=ready; /*将就绪队列的第一个进程投入运行*/
ready=ready-next;
run-state='R';
}
void RR() //时间片轮转调度
{
while(run!=NULL)
{
run-cputime=run-cputime+1;
run-needtime=run-needtime-1;
if(run-needtime==0) /*运行完将其变为完成态，插入完成队列*/
{
run-next=finish;
finish=run;
run-state='F';
run=NULL;
if(ready!=NULL)
firstin(); /*就绪对列不空，将第一个进程投入运行*/
}
else
if(ready!=NULL) /*如就绪队列不空*/
{
run-state='W'; /*将进程插入到就绪队列中等待轮转*/
insert(run);
firstin(); /*将就绪对列的第一个进程投入运行*/
}
printf("------------------------------------------------------------------\n");
print(); /*输出进程信息*/
}
}
void FCFS(double *arrive,double *runtime,double n) //先来先服务调度算法
{
start[0]=arrive[0]; //开始执行时间=到达时间
endtime[0]=start[0]+runtime[0]; //完成时间=开始时间+服务时间
zhou[0]=endtime[0]-arrive[0]; //周转时间=完成时间-到达时间
dqzhou[0]=zhou[0]/runtime[0];
for(int i=0;in;i++)
{
if(endtime[i-1]arrive[i]||endtime[i-1]==arrive[i])
endtime[i]=endtime[i-1]+runtime[i];
else
endtime[i]=arrive[i]+runtime[i];
zhou[i]=endtime[i]-arrive[i];
dqzhou[i]=zhou[i]/runtime[i];
averagezhou+=zhou[i];
average_zhou+=dqzhou[i];
}
averagezhou=averagezhou/n;
average_zhou=average_zhou/n;
cout"完成时间为:"endl;
for(int j=0;jn;j++)
coutendtime[j]" "endl;
cout"周转时间为:"endl;
for(int k=0;kn;k++)
coutzhou[k]" "endl;
cout"带权周转时间为:"endl;
for(int m=0;mn;m++)
coutdqzhou[m]" "endl;
cout"平均周转时间为:"endl;
coutaveragezhou" "endl;
cout"平均带权周转时间为:"endl;
coutaverage_zhou" "endl;
}
void SJF(double *arrive,double *runtime,double n) //短作业优先调度算法
{
int end[maxnum]; //用于标记进程是否已经执行，应经执行end[i]=1,否则为0;
for(int k=0;kn;k++)
end[k]=0;
int temp,now=0,next=1,p=1; //now表示刚执行完的进程号，next表示下一个要执行的进程号
start[0]=arrive[0]; //开始执行时间=到达时间
endtime[0]=start[0]+runtime[0]; //完成时间=开始时间+服务时间
zhou[0]=endtime[0]-arrive[0]; //周转时间=完成时间-到达时间
dqzhou[0]=zhou[0]/runtime[0]; //带权周转时间=周转时间/服务时间
averagezhou=zhou[0];
average_zhou=dqzhou[0];
end[now]=1; //执行完的进程设置为1；
for(int i=1;in;i++)
{
int j;
for(j=1;jn;)
{
if(arrive[j]endtime[now]||arrive[j]==endtime[now])
j++;
else
break;
}
temp=j;
int min=p;
for(j=1;j=temp;j++)
{
if(runtime[min]runtime[j] end[j]==0)
min=j;
}
next=min;
endtime[next]=endtime[now]+runtime[next];
zhou[next]=endtime[next]-arrive[next];
dqzhou[next]=zhou[next]/runtime[next];
averagezhou+=zhou[next];
average_zhou+=dqzhou[next];
end[next]=1;
now=next;
next=p;
while(end[p]!=0)
p++;
}
averagezhou=averagezhou/n;
average_zhou=average_zhou/n;
cout"完成时间为:"endl;
for(int j=0;jn;j++)
coutendtime[j]" "endl;
cout"周转时间为:"endl;
for(k=0;kn;k++)
coutzhou[k]" "endl;
cout"带权周转时间为:"endl;
for(int m=0;mn;m++)
coutdqzhou[m]" "endl;
cout"平均周转时间为:"endl;
coutaveragezhou" "endl;
cout"平均带权周转时间为:"endl;
coutaverage_zhou" "endl;
}
int EDF() //最早截止时间的调度算法
{
int arrive_A,arrive_B; //标记进程A,进程B的到达时间
int zhouqi_A,zhouqi_B,serve_A,serve_B; //进程的周期时间和服务时间
int i,j,a=0,b=0,ka=0,kb=0; //ka,kb为开关,i,j,a,b为进程下标
int num_a=0,num_b=0; //服务累计时间
printf("输入进程A的周期时间,服务时间: ");
scanf("%d%d",zhouqi_A,serve_A);
printf("输入进程B的周期时间,服务时间: ");
scanf("%d%d",zhouqi_B,serve_B);
for(int T=0;T=100;T++)
{
if(num_a==serve_A) //进程A完成
{
num_a=serve_A+1;
printf("当T=%d时",T);
printf("进程A%d结束\n",a);
if(num_bserve_B)
{
printf(" 调用进程B%d\n",b);
kb=1;
}
ka=0;
}
if(num_b==serve_B)
{
num_b=serve_B+1;
printf("当T=%d时",T);
printf("进程B%d结束\n",b);
if(num_aserve_A)
{
printf(" 调用进程A%d\n",a);
ka=1;
}
kb=0;
}
if(T%zhouqi_A==0 T%zhouqi_B==0)
{
arrive_A=arrive_B=T;
j=++a;
i=++b;
printf("当T=%d时,进程A%d和进程B%d同时产生，此时，",T,j,i);
if(zhouqi_A=zhouqi_B)
{
printf("调用进程A%d，阻塞进程B%d\n",j,i);
ka=1;
kb=0;
}
else
{
printf("调用进程B%d，阻塞进程A%d\n",i,j);
ka=0;
kb=1;
}
num_a=num_b=0;
}
if(T%zhouqi_A==0T%zhouqi_B!=0)
{
arrive_A=T;
printf("当T=%d时",T);
printf("进程A%d产生 ",++a); //不可能与进程A竞争处理器
num_a=0;
if(num_bserve_B) //进程B没有完成
if(arrive_B+zhouqi_Barrive_A+zhouqi_A) //若进程B最早截止时间大于进程A的,则执行进程A
{
printf("进程A%d执行。\n",a);
ka=1;
kb=0;
}
else //若进程B最早截止时间小于等于进程A的
printf("进程B%d继续执行。\n",b);
else //进程B完成
{
printf("进程A%d执行。\n",a);
ka=1;
}
}
if(T%zhouqi_A!=0 T%zhouqi_B==0)
{
arrive_B=T;
printf("当T=%d时",T);
printf("进程B%d产生，",++b); //不可能与进程B竞争处理器
num_b=0;
if(num_aserve_A) //进程A没有完成
if(arrive_B+zhouqi_B=arrive_A+zhouqi_A) //进程A的最早截止时间不小于B
printf("进程A%d继续执行。\n",a);
else
{
printf("进程B%d执行。\n",b);
kb=1;
ka=0;
}
else //进程A完成
{
printf("进程B%d执行。\n",b);
kb=1;
}
}
if(ka)
num_a++;
if(kb)
num_b++;
}
return 1;
}
int main()
{
system("color 0b"); //设置颜色
cout"最早截止时间的调度算法如下: "endlendl;
EDF();
int n;
coutendl;
cout"请输入进程的数目: ";
cinn;
cout"请按进程到达时间从小到大依次输入n个进程的到达时间: "endl;
for(int i=0;in;i++)
cinarrive[i];
cout"请按上面进程的顺序依次输入n个进程的服务时间: "endl;
for(int j=0;jn;j++)
cinruntime[j];
cout"先来先服务调度算法如下: "endl;
FCFS(arrive,runtime,n);
coutendlendl;
cout"短作业优先调度算法如下: "endl;
SJF(arrive,runtime,n);
coutendlendl;
printf("轮转调度算法如下:\n\n");
printf("输入创建进程的数目:\n");
scanf("%d",N);
create();
RR();
return 0；
}
短作业优先算法用c语言如何写?
这样写应该可以：
#includeiostream.h
#includestdio.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=0;in-1;i++)
{
k=i;
for(j=i+1;jn;j++)
if(pro[k].come_timepro[j].come_time)
k=j;
if(k!=i)
{
temp=pro[i];
pro[i]=pro[k];
pro[k]=temp;
}
}
for(i=0;in;i++)
{ 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个进程的周转时间
coutpro[i].pno" "pro[i].come_time" "pro[i].run_time" "(time-pro[i].come_time)/pro[i].run_timeendl;
}
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_timepro1.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=1;in;i++)
{
if(pro[first].come_timepro[i].come_time) first=i;
flag[i]=0;
}
flag[first]=1;
time=(float)pro[first].run_time;
weight_time=1;
coutpro[first].pno" "pro[first].come_time" "pro[first].run_time" "weight_timeendl;
//pro_temp[0]=pro[first];
count=n-1;
while(count)
{
k=0;
min=32767; //设置一个较大的阈值，
for(i=0;in;i++) //找到一个未被访问的，作业较短的且已经到达内存的作业调度
if((i!=first)(flag[i]==0)(time=pro[i].come_time)(minpro[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;
coutpro[k].pno" "pro[k].come_time" "pro[k].run_time" "(time-pro[k].come_time)/pro[k].run_timeendl;
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}};
coutfcfs(pro,5)endl;
coutsjp(pro,5)endl;
}
求一份儿C语言优先级调度算法要求如下
#include "string.h"
#define n 10 /*假定系统中可容纳的作业数量为n*/
typedef struct jcb
{char name[4]; /*作业名*/
int length; /*作业长度，所需主存大小*/
int printer; /*作业执行所需打印机的数量*/
int tape; /*作业执行所需磁带机的数量*/
int runtime; /*作业估计执行时间*/
int waittime; /*作业在系统中的等待时间*/
int next; /*指向下一个作业控制块的指针*/
}JCB; /*作业控制块类型定义*/
int head; /*作业队列头指针定义*/
int tape,printer;
long memory;
JCB jobtable[n]; /*作业表*/
int jobcount=0; /*系统内现有作业数量*/
shedule( )
/*作业调度函数*/
{float xk,k;
int p,q,s,t;
do
{p=head;
q=s=-1;
k=0;
while(p!=-1)
{ if(jobtable[p].length=memoryjobtable[p].tape=tapejobtable[p].printer=printer)
{ /*系统可用资源是否满足作业需求*/
xk=(float)(jobtable[p].waittime)/jobtable[p].runtime;
if(q==0||xkk) /*满足条件的第一个作业或者作业q的响应比小于作业p的响应比*/
{k=xk; /*记录响应比*/
q=p;
t=s;
}/*if*/
}/*if*/
s=p;
p=jobtable[p].next; /*指针p后移*/
}/*while*/
if(q!=-1)
{ if(t==-1) /*是作业队列的第一个*/
head=jobtable[head].next;
else
jobtable[t].next=jobtable[q].next;
/*为作业q分配资源：分配主存空间；分配磁带机;分配打印机*/
memory=memory-jobtable[q].length;
tape=tape-jobtable[q].tape;
printer=printer-jobtable[q].printer;
printf("选中作业的作业名：%s\n",jobtable[q].name);
}
}while(q!=-1);
}/*作业调度函数结束*/
main( )
{char name[4];
int size,tcount,pcount,wtime,rtime;
int p;
/*系统数据初始化*/
memory=65536;
tape=4;
printer=2;
head=-1;
printf("输入作业相关数据(以作业大小为负数停止输入)：\n");
/*输入数据，建立作业队列*/
printf("输入作业名、作业大小、磁带机数、打印机数、等待时间、估计执行时间\n");
scanf("%s%d%d %d %d %d",name,size,tcount,pcount,wtime,rtime);
while(size!=-1)
{/*创建JCB*/
if(jobcountn)p=jobcount;
else { printf("无法再创建作业\n");
break;
}
jobcount++;
/*填写该作业相关内容*/
strcpy(jobtable[p].name,name);
jobtable[p].length=size;
jobtable[p].printer=pcount;
jobtable[p].tape=tcount;
jobtable[p].runtime=rtime;
jobtable[p].waittime=wtime;
/*挂入作业队列队首*/
jobtable[p].next=head;
head=p;
/* 输入一个作业数据*/
printf("输入作业名、作业大小、磁带机数、打印机数、等待时间、估计执行时间\n");
scanf("%s%d%d%d%d%d",name,size,tcount,pcount,wtime,rtime);
}/*while*/
shedule( ); /*进行作业调度*/
}/*main( )函数结束*/
操作系统的作业，用C语言模拟先来先服务的方法的进程调度，请大神帮忙看看我这个代码有什么问题
假设你的系统是win7,而你参照的代码是在xp上面写的【就是调用xp的底层的接口】，有些会出现这种问题。。。你就行你安装一个不符合这个系统版本的软件，不是也是会提示类似的错误？
求进程调度先来先服务算法，短进程优先算法完整c语言代码
/*（一）进程调度
进程调度算法有FIFO，优先数调度算法，时间片轮转调度算法，分级调度算法，
输入：进程流文件，其中存储的是一系列要执行的进程，
每个作业包括三个数据项：
进程名 所需时间 优先数(0级最高)
输出:
进程执行流 等待时间 平均等待时间
本程序包括:FIFO，优先数调度算法，时间片轮转调度算法
进程流文件process_stream.txt
测试数据：
p0 16 2
p1 5 1
p2 4 3
p3 8 0
p4 9 4
p5 7 6
VC++调试通过
*/
#include stdio.h
#include string.h
#include iostream.h
#include stdlib.h
const int Quatum=2;//定义时间片的长度为2秒
const int MAXPCB=100;//定义最大进程数
//定义进程结构体
typedef struct node
{
char name[20];//进程名
int time; //进程运行时间
int privilege;//进程优先级（静态）
int finished;//进程完成标志，0-未完成，1-已完成
int wait_time;//进程等待时间
}pcb;
pcb pcbs[MAXPCB];
int quantiry;//进程流文件中的进程总数
void initial()
{
int i;
for (i=0;iMAXPCB;i++)
{
strcpy(pcbs[i].name,"");
pcbs[i].time=0;
pcbs[i].privilege=0;
pcbs[i].finished=0;
pcbs[i].wait_time=0;
}
quantiry=0;
}
int readData()
{
FILE *fp;
char fname[20];
int i;
cout"请输入进程流文件名:"endl;
cinfname;
if ((fp=fopen(fname,"r"))==NULL)
{
cout"错误,文件打不开，请检查文件名"endl;
}
else
{
while (!feof(fp))
{
fscanf(fp,"%s %d %d %d",pcbs[quantiry].name,
pcbs[quantiry].time,pcbs[quantiry].privilege);
quantiry++;
}
//输出所读入得数据
cout"输出所读入的数据"endl;
cout"进程流文件中的进程总数="quantiryendl;
cout"进程名 所需时间 优先数"endl;
for (i=0;iquantiry;i++)
{
cout" "pcbs[i].name" "pcbs[i].time" "pcbs[i].privilegeendl;
}
return 1;
}
return 0;
}
//重置数据，以供另一个算法使用
void init()
{
int i;
for (i=0;iMAXPCB;i++)
{
pcbs[i].finished=0;
pcbs[i].wait_time=0;
}
}
void FIFO()
{
int i,j;
int total;
//输出FIFO算法执行流
coutendl"---------------------------------------------------------------"endl;
cout"FIFO算法执行流:"endl;
cout"进程名 等待时间"endl;
for (i=0;iquantiry;i++)
{
cout" "pcbs[i].name" "pcbs[i].wait_timeendl;
for (j=i+1;jquantiry;j++)
{
pcbs[j].wait_time+=pcbs[i].time;
}
}
total=0;
for (i=0;iquantiry;i++)
{
total+=pcbs[i].wait_time;
}
cout"总等待时间:"total" ""平均等待时间:"total/quantiryendl;
}
//优先度调度算法
void privilege()
{
int i,j,p;
int passed_time=0;
int total;
int queue[MAXPCB];
int current_privielege=1000;
for (i=0;iquantiry;i++)
{
current_privielege=1000;
for (j=0;jquantiry;j++)
{
if ((pcbs[j].finished==0)(pcbs[j].privilegecurrent_privielege))
{
p=j;
current_privielege=pcbs[j].privilege;
}
}
queue[i]=p;
pcbs[p].finished=1;
pcbs[p].wait_time+=passed_time;
passed_time+=pcbs[p].time;
}
//输出优先数调度执行流
coutendl"-----------------------------------------"endl;
cout"优先数调度执行流:"endl;
cout"进程名 等待时间"endl;
for (i=0;iquantiry;i++)
{
cout" "pcbs[queue[i]].name" "pcbs[queue[i]].wait_time"--"queue[i]endl;
}
total=0;
for (i=0;iquantiry;i++)
{
total+=pcbs[i].wait_time;
}
cout"总等待时间:"total" 平均等待时间:"total/quantiryendl;
}
//时间片轮转调度算法
void timer()
{
int i,j,sum,flag=1;
int passed_time=0;
int max_time=0;
int round=0;
int queue[1000];
int total=0;
while(flag==1)
{
flag=0;
for (i=0;iquantiry;i++)
{
if (pcbs[i].finished==0)
{
flag=1;
queue[total]=i;
total++;
if (pcbs[i].time=Quatum*(round+1))
pcbs[i].finished=1;
}
}
round++;
}
coutendl"---------------------------------------------------------------"endl;
cout"时间片轮转调度执行流:";
for(i=0;itotal;i++)
{
coutpcbs[queue[i]].name" ";
}
coutendl;
cout"进程名 结束时间 运行时间 等待时间"endl;
sum=0;
for (i=0;iquantiry;i++)
{
for(j=total-1;j=0;j--)//从轮转调度执行流序列由后往前比较，找到同名进程即可计算其完成时间
{
if (strcmp(pcbs[queue[j]].name,pcbs[i].name)==0)
{
cout" "pcbs[i].name" "(j+1)*Quatum" ";
coutpcbs[i].time" "(j+1)*Quatum-pcbs[i].timeendl;
sum+=(j+1)*Quatum-pcbs[i].time;
break;
}
}
}
cout"总等待时间:"sum" ""平均等待时间:"sum/quantiryendl;
}
//显示版权信息函数
void version()
{
coutendlendl;
cout" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"endl;
cout" ┃ 进程调度模拟系统 ┃"endl;
cout" ┠───────────────────────┨"endl;
cout" ┃ version 2011 ┃"endl;
cout" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"endl;
coutendlendl;
}
//主函数
int main()
{
int flag;
version();
initial();
flag=readData();
if(flag==1){
FIFO();
init();
privilege();
init();
timer();
}
coutendl;
system("pause");
return 0;
}
急求 程序代码 c/c++ 操作系统中的 处理机调度算法
#include iostream
#include stdio.h
#include string
//#include windows.h
using namespace std;
//hyugtyftydrtdtrdrrtrdrt
struct Node
{
string name;//进程（作业）名称
int arriveTime;//到达时间
int ServerTime;//服务时间
int leftTime;//the left time
Node *link;//指向下一个节点的指针
};
class CProcess
{
public:
CProcess();//构造函数
~CProcess();//析构函数
const CProcess operator =(const CProcess p);//重载赋值操作符
void insertNode(string na,int at,int st);//插入新元素（at由小到大）到链表合适的位置
void sort();//按照服务时间由大到小排序
bool isEmpty();//判断是否为空
void destroy();//销毁
int length();//求出链表长度
void print();//打印出元素
void FCFS();//先到先服务
void SJF();//短进程(作业)优先
void RR(int q);//时间片轮转
void priority();//优先权调度
protected:
Node *first;
Node *last;
};
const CProcess CProcess::operator=(const CProcess p)
{
Node *newNode;
Node *Current;
if(this!=p)//避免自己给自己赋值
{
if(first!=NULL)//如果链表不为空
destroy();
if(p.first==NULL)
{//如果要拷贝的对象为空
this-first = NULL;
this-last = NULL;
}
else
{
Current = p.first;
first= new Node;
first-name=Current-name;//
first-arriveTime=Current-arriveTime;
first-ServerTime=Current-ServerTime;
first-link =NULL;
last =first;
Current = Current-link;
while(Current!=NULL)
{
newNode = new Node;
newNode-name=Current-name;
newNode-arriveTime=Current-arriveTime;
newNode-ServerTime=Current-ServerTime;
newNode-link=NULL;
last-link=newNode;
last=newNode;
Current = Current-link;
}
}
}
return *this;
}
CProcess::CProcess()
{//构造函数
first=NULL;
last=NULL;
}
CProcess::~CProcess()
{
Node *temp;
while(first!=NULL)
{
temp=first;
first=first-link;
delete temp;
}
last=NULL;
}
void CProcess::insertNode(string na,int at,int st)
{//按照到达时间升序排序
Node *Current;
Node *trailCurrent;//指向Current的前一个节点
Node *newNode;
bool found;
newNode = new Node;//建立一个新节点
newNode-name=na;
newNode-arriveTime=at;
newNode-ServerTime=st;
newNode-link=NULL;//
if(first==NULL)//如果第一个节点为空（如果是第一次插入元素）
first=newNode;//将新节点赋给第一个节点
else
{//如果不是第一次
Current =first;
found = false;
while(Current!=NULL !found)
{
if(Current-arriveTime = at)
found = true;
else
{
trailCurrent = Current;
Current = Current-link;
}
}
if(Current==first)
{
newNode-link = first;
first = newNode;
}
else
{
trailCurrent-link = newNode;
newNode-link = Current;
}
}
}
int CProcess::length()
{
int count =0;//声明变量，并初始化为0（用来记录长度）
Node *Current;
Current = first;
while(Current!=NULL)//当前节点不为空，记录值自加，一直向后遍历,
{
count++;
Current = Current-link;
}
return count;//返回长度
}
void CProcess::sort()//按照服务时间，升序排列
{//冒泡排序
string sname;
int at;
int st;
Node *Current;//指向当前节点
Node *trailCurrent;//指向当前节点的前一个节点
for(trailCurrent=first-link;trailCurrent!=NULL;trailCurrent=trailCurrent-link)//控制条件有问题
{
for(Current=trailCurrent-link;Current!=NULL;Current=Current-link)//控制条件有问题
{
if(trailCurrent-ServerTime Current-ServerTime)
{
sname=trailCurrent-name;
at=trailCurrent-arriveTime;
st=trailCurrent-ServerTime;
trailCurrent-name=Current-name;
trailCurrent-arriveTime=Current-arriveTime;
trailCurrent-ServerTime=Current-ServerTime;
Current-name=sname;
Current-arriveTime=at;
Current-ServerTime=st;
}
}
}
}
bool CProcess::isEmpty()//判断是否为空
{
return (first==NULL);//如果第一个节点为空，返回值
}
void CProcess::print()
{
Node *Current;
Current = first-link;//头节点赋给当前节点
while(Current!=NULL)//当前节点不为空，一直向后遍历打印
{
coutCurrent-name" ";
coutCurrent-arriveTime" ";
coutCurrent-ServerTime"\n";
Current = Current-link;
}
}
void CProcess::destroy()
{
Node *temp;//定义一个临时指针变量
while(first!=NULL)
{
temp=first;
first=first-link;
delete temp;
}
last=NULL;
}
void CProcess::FCFS()//先到先服务
{
Node *Current;
int T0=0;//完成时间
int T1=0;//周转时间
Current = first-link;//头节点赋给当前节点
while(Current!=NULL)
{
if(T0 Current-arriveTime)
{
T0=Current-arriveTime+Current-ServerTime;
T1=T0-Current-arriveTime;
coutCurrent-name"\t";//打印出进程名
coutT0"\t";//打印出完成时间
coutT1"\n";//打印出周转时间
Current = Current-link;
}
else
{
T0=Current-ServerTime+T0;
T1=T0-Current-arriveTime;//周转时间等于，完成时间 - 到达时间
coutCurrent-name"\t";//打印出进程名
coutT0"\t";//打印出完成时间
coutT1"\n";//打印出周转时间
Current = Current-link;
}
}
}
void CProcess::SJF()//短进程(作业)优先
{
//首先执行第一个到达的作业
Node *Current;
int T0=0;//完成时间
int T1=0;//周转时间
T0=first-link-ServerTime+T0;
T1=T0-first-link-arriveTime;
coutfirst-link-name"\t";
coutT0"\t";//打印出完成时间
coutT1"\n";//打印出周转时间
first-link=first-link-link;//删除
//执行剩下的
sort();//对剩下的排序
Current = first-link;//头节点赋给当前节点
while(Current!=NULL)
{
if(T0 Current-arriveTime)
{
T0=Current-arriveTime+Current-ServerTime;
T1=T0-Current-arriveTime;
coutCurrent-name"\t";//打印出进程名
coutT0"\t";//打印出完成时间
coutT1"\n";//打印出周转时间
Current = Current-link;
}
else
{
T0=Current-ServerTime+T0;
T1=T0-Current-arriveTime;//周转时间等于，完成时间 - 到达时间
coutCurrent-name"\t";//打印出进程名
coutT0"\t";//打印出完成时间
coutT1"\n";//打印出周转时间
Current = Current-link;
}
}
}
void CProcess::RR(int q)//时间片轮转
{
cout"时间片轮转操作完成！\n";
}
void CProcess::priority()//优先权调度
{
cout"优先权操作完成！\n";
}
void main()
{
CProcess p0,p1,p2,p3,p4;
int at,st;
string na;
int judge=1;//控制退出程序
int choice;//控制选择操作
while(judge)
{
cout"********************************************************\n";
cout"****** 说明：本程序适用于单道进程（作业） ******\n";
cout"******** 请选择您的操作 ***************\n";
cout"*********输入相应的数字，按下（Enter）键！**************\n";
cout"************* 5.录入信息 ************\n";
cout"************* 1.先到先服务 ************\n";
cout"************* 2.短进程（作业）优先 ************\n";
cout"************* 3.时间片轮转 ************\n";
cout"************* 4.优先权(静态)调度 ************\n";
cout"************* 0.退出程序 ************\n";
cout"********************************************************\n";
cinchoice;
switch(choice)
{
case 0:
judge=0;
break;
case 5:
cout"请输入信息以“end”结束输入！\n";
cout"进程名 到达时间 服务时间"endl;
while(na.compare("end"))//如果相等则会返回0
{
p0.insertNode(na,at,st);
cinnaatst;
}
cout"录入成功，目前的信息为：\n";
cout"进程名 到达时间 服务时间"endl;
p0.print();
break;
case 1://先到先服务
p1=p0;//拷贝一份
if(p1.isEmpty())
{
cout"请先录入信息\n";
break;
}
else
{
cout"先到先服务\n";
cout"进程名 完成时间 周转时间\n";
p1.FCFS();
break;
}
case 2://短作业优先
p2=p0;//拷贝一份
//p2.sort();
//p2.print();
if(p2.isEmpty())
{
cout"请先录入信息\n";
break;
}
else
{
cout"短作业优先\n";
cout"进程名 完成时间 周转时间\n";
p2.SJF();
break;
}
case 3://时间片轮转
p3=p0;//拷贝一份
int q;
if(p3.isEmpty())
{
cout"请先录入信息\n";
break;
}
else
{
cout"请输入时间片大小";
cinq;
cout"时间片轮转\n";
cout"进程名 完成时间 周转时间\n";
p3.RR(q);
break;
}
case 4://优先权
p4=p0;//拷贝一份
if(p4.isEmpty())
{
cout"请先录入信息\n";
break;
}
else
{
cout"时间片轮转\n";
cout"进程名 完成时间 周转时间\n";
p4.priority();
break;
}
default:
cout"请选择目录中的选项！\n";
break;
}
}
return;
}
