#include <windows.h>
#include <stdlib.h>
typedef struct JOB
{
int hour//用于存储输入的时
int min//用于存储输入的分
int ID//记录此作业的号
int requesttime//存储作业所估计运行时间
int runtime//作业周转时间
int cometime//作业进入时间
int finishtime//作业结束时间
int starttime//作业开始时间
float runtime2//带权周转时间
int prior//响应比
}JOB
float counttime1=0//用于存储总的扮早周转时间
float counttime2=0//用于存储总的带权周转时间
int nowtime
int flat=0
int sign=0
void insert(JOB [],JOB)
void FCFS()
void SJF()
void HRN()
void getprior(JOB a,int b)
int getmin(int i)
int gethour(int i)
int trans(int i,int j)
#define N 100
JOB job[N]
JOB wait[N]//用于SJF中存储等待的作业的时间
JOB job2[N]//由于在SJF中不好控制输出时按照作业序号的顺序输出，用一个数组存储
int co=0
int jobnum
void main()
{
int i
printf("输入作业数：\n")
scanf("%d",&i)
jobnum=i
FILE *fp
fp = fopen("in.txt","rb")
if(fp == NULL)
{
printf("Can't open in.txt")
exit(0)
}
for(int j=0j<ij++)
{
fscanf(fp,"%d:%d %d",&job[j].hour,&job[j].min,&job[j].requesttime)
job[j].ID=j+1
job[j].cometime=job[j].hour*60 + job[j].min
printf("%d\n",job[j].requesttime)
}
printf("\n ================================")
printf("\厅基雀n | 1:FCFS 2:SJF|")
printf("\n | 3:HRN |")
printf("\n ================================")
printf("\nPlease select a number from (1,2,3):")
scanf("%d",&i)
switch(i)
{
case 1: FCFS()break
case 2: SJF()break
case 3: HRN()break
}
}
void FCFS()
{
printf("\n\n根据先来先服务算法：锋空\n")
int k
for(int i=0i<jobnum-1i++)//将作业数组按照进入时间先后排序。
{
k=i
for(int j=i+1j<jobnumj++)
{
if(job[j].cometime<job[k].cometime) k=j
}
if(k!=i)
{
JOB a
a=job[k]
job[k]=job[i]
job[i]=a
}
}
for(int i=0i<jobnumi++)
{
if(i==0)//如果是第一个任务
{
job[i].starttime=job[i].cometime
job[i].finishtime=job[i].starttime+job[i].requesttime
job[i].runtime=job[i].finishtime-job[i].cometime
job[i].runtime2=(float)job[i].runtime/(float)job[i].requesttime
counttime1+=job[i].runtime
counttime2+=job[i].runtime2
}
else
{
job[i].starttime=(job[i-1].finishtime>job[i].cometime ? job[i-1].finishtime : job[i].cometime)
job[i].finishtime=job[i].starttime+job[i].requesttime
job[i].runtime=job[i].finishtime-job[i].cometime
job[i].runtime2=(float)job[i].runtime/(float)job[i].requesttime
counttime1+=job[i].runtime
counttime2+=job[i].runtime2
}
}
printf("作业 进入时间 估计运行时间 开始时间 结束时间 周转时间 带权周转时间\n")
FILE *fp
fp = fopen("FCFS.txt","w")
if(fp==NULL)
{
printf("Can't create file : SJF.txt\n")
exit(0)
}
fprintf(fp,"作业 进入时间 估计运行时间 开始时间 结束时间 周转时间 带权周转时间\n")
for(int i=0i<jobnum-1i++)//将作业数组按照作业的ID排序
{
k=i
for(int j=i+1j<jobnumj++)
if(job[j].ID<job[k].ID)
k=j
if(k!=i)
{
JOB a
a=job[k]
job[k]=job[i]
job[i]=a
}
}
for(int i=0i<jobnumi++)
{
int a,b,c,d
a=gethour(job[i].starttime)
b=getmin(job[i].starttime)
c=gethour(job[i].finishtime)
d=getmin(job[i].finishtime)
printf("JOB%d ",job[i].ID)
fprintf(fp,"JOB%d ",job[i].ID)
if(job[i].min==0)
{
printf("%d:%d0 ",job[i].hour,job[i].min)
fprintf(fp,"%d:%d0 ",job[i].hour,job[i].min)
}
else
{
printf("%d:%d ",job[i].hour,job[i].min)
fprintf(fp,"%d:%d ",job[i].hour,job[i].min)
}
printf("%11d ",job[i].requesttime)
fprintf(fp,"%11d ",job[i].requesttime)
if(b==0)
{
printf("%d:%d0 ",a,b)
fprintf(fp,"%d:%d0 ",a,b)
}
else
{
printf("%d:%d ",a,b)
fprintf(fp,"%d:%d ",a,b)
}
if(d==0){
printf("%d:%d0 ",c,d)
fprintf(fp,"%d:%d0 ",c,d)
}
else{
printf("%d:%d ",c,d)
fprintf(fp,"%d:%d ",c,d)
}
printf("%11d%11f\n",job[i].runtime,job[i].runtime2)
fprintf(fp,"%13d%13f\n",job[i].runtime,job[i].runtime2)
}
printf("【平均周转周期为:%f】\n【平均带权周转时间：%f】",(float)counttime1/jobnum,counttime2/jobnum)
fprintf(fp,"【平均周转周期为:%f】\n【平均带权周转时间：%f】",(float)counttime1/jobnum,counttime2/jobnum)
system("pause")
}
int trans(int i,int j)
{
return i*60 + j
}
int gethour(int i)
{
return i/60
}
int getmin(int i)
{
return i%60
}
void SJF()
{
printf("\n\n根据短作业优先算法：\n")
int k
for(int i=0i<jobnum-1i++)//将作业数组按照进入时间先后排序。
{
k=i
for(int j=i+1j<jobnumj++)
{
if(job[j].cometime<job[k].cometime) k=j
}
if(k!=i)
{
JOB a
a=job[k]
job[k]=job[i]
job[i]=a
}
}
int numbers=jobnum
int realnum=jobnum
for(int i=0i<numbersi++)
{
if(i==0)//假如是第一个，则直接进入cpu进行作业
{
job[i].starttime=job[i].cometime
job[i].finishtime=job[i].starttime+job[i].requesttime
job[i].runtime=job[i].finishtime-job[i].cometime
job[i].runtime2=(float)job[i].runtime/(float)job[i].requesttime
nowtime=job[i].finishtime
counttime1+=job[i].runtime
counttime2+=job[i].runtime2
job2[co++]=job[i]
for(int u=0u<jobnum-1u++)//把第一个从job序列的移除
job[u]=job[u+1]
jobnum--
int j=0
while(job[j].cometime<=nowtime&&j<jobnum)//从剩余的job序列中获取正在等待的job，放进wait序列中
{
wait[flat++]=job[j++]
}
int i=0
if(j!=0)//j!=0则表明已经从job序列中转移了job到wait序列中
{
while(j<jobnum)//将已经转移的job从job序列中移除
{
job[i]=job[j]
i++
j++
}
jobnum=i
}
if(flat>1)//如果wait序列中不止一个等待作业
{
int r
for(int x=0x<flat-1x++)//将等待数组按照估计运行时间先后排序。
{
r=x
for(int y=x+1y<flaty++)
{
if(wait[y].requesttime<wait[r].requesttime)
r=y
}
if(r!=x)
{
JOB a
a=wait[r]
wait[r]=wait[x]
wait[x]=a
}
}
}
}
else
{
if(flat==0)//如果wait序列中没有，即没有等待的序列，则将job序列中的第一个作业放入cpu进行运行
{
job[0].starttime=job[0].cometime
job[0].finishtime=job[0].starttime+job[0].requesttime
job[0].runtime=job[0].finishtime-job[0].cometime
job[0].runtime2=(float)job[0].runtime/(float)job[0].requesttime
nowtime=job[0].finishtime
counttime1+=job[0].runtime
counttime2+=job[0].runtime2
job2[co++]=job[0]
for(int u=0u<jobnum-1u++)//将放入运行的作业从job序列中移除
job[u]=job[u+1]
jobnum--
int j=0
while(job[j].cometime<=nowtime&&j<jobnum)//从剩余的job序列中获取正在等待的job，放进wait序列中
{
wait[flat++]=job[j++]
}
int i=0
if(j!=0)//j!=0则表明已经从job序列中转移了job到wait序列中
{
while(j<jobnum)
{
job[i]=job[j]
i++
j++
}
jobnum=j
}
int r
if(flat>1)//如果wait序列中不止一个等待作业
{
for(int x=0x<flat-1x++)//将等待数组按照估计运行时间先后排序。
{
r=x
for(int y=x+1y<flaty++)
{
if(wait[y].requesttime<wait[r].requesttime) r=y
}
if(r!=x)
{
JOB a
a=wait[r]
wait[r]=wait[x]
wait[x]=a
}
}
}
}
else//否则如果wait序列中有等待作业，则调用wait序列的第一个作业
{
wait[0].starttime=nowtime
wait[0].finishtime=nowtime+wait[0].requesttime
wait[0].runtime=wait[0].finishtime-wait[0].cometime
wait[0].runtime2=(float)(wait[0].runtime)/(float)(wait[0].requesttime)
nowtime=wait[0].finishtime
counttime1+=wait[0].runtime
counttime2+=wait[0].runtime2
job2[co++]=wait[0]
for(int i=0i<flati++)//将wait序列的第一个作业从wait中移除
wait[i]=wait[i+1]
flat--
int j=0
while(job[j].cometime<=nowtime&&j<jobnum)//从剩余的job序列中获取正在等待的job，放进wait序列中
{
wait[flat++]=job[j++]
}
int i=0
if(j!=0)//j!=0则表明已经从job序列中转移了job到wait序列中
{
if(j==1&&jobnum==1)//job序列中最后一个作业已经转移到wait中，则将jobnum自减一到0
jobnum--
else
{
while(j<jobnum)//否则将已转移的作业从job中移除
{
job[i]=job[j]
i++
j++
}
jobnum=j
}
}
int r
if(flat>1)//如果wait里的等待序列多余一个，则进行重新排序
{
for(int x=0x<flat-1x++)//将等待数组按照估计运行时间先后排序。
{
r=x
for(int y=x+1y<flaty++)
{
if(wait[y].requesttime<wait[r].requesttime)
r=y
}
if(r!=x)
{
JOB a
a=wait[r]
wait[r]=wait[x]
wait[x]=a
}
}
}
}
}
}
printf("作业 进入时间 估计运行时间 开始时间 结束时间 周转时间 带权周转时间\n")
FILE *fp
fp = fopen("SJF.txt","w")
if(fp==NULL)
{
printf("Can't create file : SJF.txt\n")
exit(0)
}
fprintf(fp,"作业 进入时间 估计运行时间 开始时间 结束时间 周转时间 带权周转时间\n")
for(int i=0i<realnum-1i++)//将作业数组按照作业的ID排序
{
k=i
for(int j=i+1j<realnumj++)
if(job2[j].ID<job2[k].ID)
k=j
if(k!=i)
{
JOB a
a=job2[k]
job2[k]=job2[i]
job2[i]=a
}
}
for(int i=0i<realnumi++)
{
int a,b,c,d
a=gethour(job2[i].starttime)
b=getmin(job2[i].starttime)
c=gethour(job2[i].finishtime)
d=getmin(job2[i].finishtime)
printf("JOB%d ",job2[i].ID)
fprintf(fp,"JOB%d ",job2[i].ID)
if(job2[i].min==0)
{
printf("%d:%d0 ",job2[i].hour,job2[i].min)
fprintf(fp,"%d:%d0 ",job2[i].hour,job2[i].min)
}
else
{
printf("%d:%d ",job2[i].hour,job2[i].min)
fprintf(fp,"%d:%d ",job2[i].hour,job2[i].min)
}
printf("%11d ",job2[i].requesttime)
fprintf(fp,"%11d ",job2[i].requesttime)
if(b==0)
{
printf("%d:%d0 ",a,b)
fprintf(fp,"%d:%d0 ",a,b)
}
else
{
printf("%d:%d ",a,b)
fprintf(fp,"%d:%d ",a,b)
}
if(d==0){
printf("%d:%d0 ",c,d)
fprintf(fp,"%d:%d0 ",c,d)
}
else{
printf("%d:%d ",c,d)
fprintf(fp,"%d:%d ",c,d)
}
printf("%11d%11f\n",job2[i].runtime,job2[i].runtime2)
fprintf(fp,"%13d%13f\n",job2[i].runtime,job2[i].runtime2)
}
printf("【平均周转周期为:%f】\n【平均带权周转时间：%f】",(float)counttime1/realnum,counttime2/realnum)
fprintf(fp,"【平均周转周期为:%f】\n【平均带权周转时间：%f】",(float)counttime1/realnum,counttime2/realnum)
system("pause")
}
void HRN()
{
co=0
printf("\n\n根据最高响应比优先算法：\n")
int k
for(int i=0i<jobnum-1i++)//将作业数组按照进入时间先后排序。
{
k=i
for(int j=i+1j<jobnumj++)
{
if(job[j].cometime<job[k].cometime) k=j
}
if(k!=i)
{
JOB a
a=job[k]
job[k]=job[i]
job[i]=a
}
}
nowtime=job[0].cometime
for(int i=0i<jobnumi++)
{
int j=i
int xx=i
while(j++<jobnum)//依次求得未完成的作业的优先级
job[j].prior=1+(float)(nowtime-job[j].cometime)/job[j].requesttime
int k
for(int i=xxi<jobnum-1i++)//将作业数组按照响应比由高到低排序。
{
k=i
for(int j=i+1j<jobnumj++)
{
if(job[j].prior>job[k].prior) k=j
}
if(k!=i)
{
JOB a
a=job[k]
job[k]=job[i]
job[i]=a
}
}
if(job[i].prior>=1)//有等待的则让等待的开始时间等于现在时间
job[i].starttime=nowtime
else
job[i].starttime=job[i].cometime//没有等待的作业的话就让下一次第一个进入的工作的时间当作其开始时间并且赋给当前时间
job[i].finishtime=job[i].starttime+job[i].requesttime
job[i].runtime=job[i].finishtime-job[i].cometime
job[i].runtime2=(float)job[i].runtime/job[i].requesttime
nowtime=job[i].finishtime
counttime1+=job[i].runtime
counttime2+=job[i].runtime2
job2[co++]=job[i]
}
printf("作业 进入时间 估计运行时间 开始时间 结束时间 周转时间 带权周转时间\n")
FILE *fp
fp = fopen("HRN.txt","w")
if(fp==NULL)
{
printf("Can't create file : SJF.txt\n")
exit(0)
}
fprintf(fp,"作业 进入时间 估计运行时间 开始时间 结束时间 周转时间 带权周转时间\n")
for(int i=0i<jobnum-1i++)//将作业数组按照作业的ID排序
{
k=i
for(int j=i+1j<jobnumj++)
if(job2[j].ID<job2[k].ID)
k=j
if(k!=i)
{
JOB a
a=job2[k]
job2[k]=job2[i]
job2[i]=a
}
}
for(int i=0i<jobnumi++)
{
int a,b,c,d
a=gethour(job2[i].starttime)
b=getmin(job2[i].starttime)
c=gethour(job2[i].finishtime)
d=getmin(job2[i].finishtime)
printf("JOB%d ",job2[i].ID)
fprintf(fp,"JOB%d ",job2[i].ID)
if(job2[i].min==0)
{
printf("%d:%d0 ",job2[i].hour,job2[i].min)
fprintf(fp,"%d:%d0 ",job2[i].hour,job2[i].min)
}
else
{
printf("%d:%d ",job2[i].hour,job2[i].min)
fprintf(fp,"%d:%d ",job2[i].hour,job2[i].min)
}
printf("%11d ",job2[i].requesttime)
fprintf(fp,"%11d ",job2[i].requesttime)
if(b==0)
{
printf("%d:%d0 ",a,b)
fprintf(fp,"%d:%d0 ",a,b)
}
else
{
printf("%d:%d ",a,b)
fprintf(fp,"%d:%d ",a,b)
}
if(d==0){
printf("%d:%d0 ",c,d)
fprintf(fp,"%d:%d0 ",c,d)
}
else{
printf("%d:%d ",c,d)
fprintf(fp,"%d:%d ",c,d)
}
printf("%11d%11f\n",job2[i].runtime,job2[i].runtime2)
fprintf(fp,"%13d%13f\n",job2[i].runtime,job2[i].runtime2)
}
printf("【平均周转周期为:%f】\n【平均带权周转时间：%f】",(float)counttime1/jobnum,counttime2/jobnum)
fprintf(fp,"【平均周转周期为:%f】\n【平均带权周转时间：%f】",(float)counttime1/jobnum,counttime2/jobnum)
system("pause")
}
作业调度
#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->linktrailCurrent!=NULLtrailCurrent=trailCurrent->link)//控制条件有问题
{
for(Current=trailCurrent->linkCurrent!=NULLCurrent=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)//当前节点不为空，一直向后遍历打印
{
cout<<Current->name<<" "
cout<<Current->arriveTime<<" "
cout<<Current->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
cout<<Current->name<<"\t"//打印出进程名
cout<<T0<<"\t"//打印出完成时间
cout<<T1<<"\n"//打印出周转时间
Current = Current->link
}
else
{
T0=Current->ServerTime+T0
T1=T0-Current->arriveTime//周转时间等于，完成时间 - 到达时间
cout<<Current->name<<"\t"//打印出进程名
cout<<T0<<"\t"//打印出完成时间
cout<<T1<<"\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
cout<<first->link->name<<"\t"
cout<<T0<<"\t"//打印出完成时间
cout<<T1<<"\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
cout<<Current->name<<"\t"//打印出进程名
cout<<T0<<"\t"//打印出完成时间
cout<<T1<<"\n"//打印出周转时间
Current = Current->link
}
else
{
T0=Current->ServerTime+T0
T1=T0-Current->arriveTime//周转时间等于，完成时间 - 到达时间
cout<<Current->name<<"\t"//打印出进程名
cout<<T0<<"\t"//打印出完成时间
cout<<T1<<"\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"
cin>>choice
switch(choice)
{
case 0:
judge=0
break
case 5:
cout<<"请输入信息以“end”结束输入！\n"
cout<<"进程名 到达时间 服务时间"<<endl
while(na.compare("end"))//如果相等则会返回0
{
p0.insertNode(na,at,st)
cin>>na>>at>>st
}
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<<"请输入时间片大小"
cin>>q
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
}
万能的vba
还是写个滴定义函数吧，返回一个字符串，分割符用半角逗号。代码如下：
Function SJF(A As Integer) As String
'设定一个循环次数100，如果查找100次未找到满足条件的，则汪和烂返回空值
Const maxCS = 100 '最大循环次数
Dim jgArr(1 To 4) As Integer
Dim mySum As Integer
Dim xhCs As Integer
Dim SYZ As Integer
xhCs = 1: SJF = ""
Do While xhCs <= maxCS
SYZ = A
For I = 1 To 4
Select Case I
Case 1, 2
jgArr(I) = Int(Rnd * 10 + 1)
Case 3
jgArr(I) = Int(Rnd * 20)
Case 4
jgArr(I) = Int(Rnd * 30)
End Select
SYZ = SYZ - jgArr(I)
Next I
If SYZ >= 0 And SYZ <= 30 Then
For I = 1 To 4
SJF = SJF &jgArr(I) &","棚迅
Next I
SJF = SJF &SYZ
Exit Do
End If
xhCs = xhCs + 1
Loop
End Function
运行结困漏果如图：
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）