#include<iostream>
#include<stdio.h>
#include<string>
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=1i<=Ni++)
{
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=0i<ni++)
{
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=0j<nj++)
cout<<endtime[j]<<" "<<endl
cout<<"周转时间为:"<<endl
for(int k=0k<nk++)
cout<<zhou[k]<<" "<<endl
cout<<"带权周转时间为:"<<endl
for(int m=0m<nm++)
cout<<dqzhou[m]<<" "<<endl
cout<<"平均周转时间为:"<<endl
cout<<averagezhou<<" "<<endl
cout<<"平均带权周转时间为:"<<endl
cout<<average_zhou<<" "<<endl
}
void SJF(double *arrive,double *runtime,double n) //短作业优先调度算法
{
int end[maxnum] //用于标记进程是否已经执行，应经执行end[i]=1,否则为0
for(int k=0k<nk++)
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=1i<ni++)
{
int j
for(j=1j<n)
{
if(arrive[j]<endtime[now]||arrive[j]==endtime[now])
j++
else
break
}
temp=j
int min=p
for(j=1j<=tempj++)
{
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=0j<nj++)
cout<<endtime[j]<<" "<<endl
cout<<"周转时间为:"<<endl
for(k=0k<nk++)
cout<<zhou[k]<<" "<<endl
cout<<"带权周转时间为:"<<endl
for(int m=0m<nm++)
cout<<dqzhou[m]<<" "<<endl
cout<<"平均周转时间为:"<<endl
cout<<averagezhou<<" "<<endl
cout<<"平均带权周转时间为:"<<endl
cout<<average_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=0T<=100T++)
{
if(num_a==serve_A)//进程A完成
{
num_a=serve_A+1
printf("当T=%d时",T)
printf("进程A%d结束\n",a)
if(num_b<serve_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_a<serve_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==0&&T%zhouqi_B!=0)
{
arrive_A=T
printf("当T=%d时",T)
printf("进程A%d产生 ",++a) //不可能与进程A竞争处理器
num_a=0
if(num_b<serve_B) //进程B没有完成
if(arrive_B+zhouqi_B>arrive_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_a<serve_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<<"最早截止时间的调度算法如下: "<<endl<<endl
EDF()
int n
cout<<endl
cout<<"请输入进程的数目: "
cin>>n
cout<<"请按进程到达时间从小到大依次输入n个进程的到达时间: "<<endl
for(int i=0i<ni++)
cin>>arrive[i]
cout<<"请按上面进程的顺序依次输入n个进程的服务时间: "<<endl
for(int j=0j<nj++)
cin>>runtime[j]
cout<<"先来先服务调度算法如下: "<<endl
FCFS(arrive,runtime,n)
cout<<endl<<endl
cout<<"短作业优先调度算法如下: "<<endl
SJF(arrive,runtime,n)
cout<<endl<<endl
printf("轮转调度算法如下:\n\n")
printf("输入创建进程的数目:\n")
scanf("%d",&N)
create()
RR()
return 0；
}
#include<stdio.h>struct pcb
{
char name
int time
}
void main()
{
int n,i,j,flag=1
struct pcb a[100]
printf("输入程序个数：")
scanf("%d",&n)
getchar()/*接收回车*/
for(i=0i<ni++)
{
printf("输入程序的名字：如A B C...\n")
scanf("%c",&a[i].name)
getchar()/*接收回车*/
printf("输入占用的时间片：")
scanf("%d",&a[i].time)
getchar()/*接收回车*/
}
i=0
while(flag &&n>0)
{
if(a[i].time!=0)
{
printf("%c",a[i].name)
a[i].time--
}
for(j=0j<nj++)
if(a[j].time)
{
flag=1
break
}
else
flag=0
i=(++i)%n
}
}
调试通过...
#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
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）