#define n 20
struct fcfs
{
int id
int atime
int runtime
int ftime
}f[n]
zcx(){
int xz
int amount
printf("**************分割线*********************\n")
printf("1.先来先服务\n")
printf("2.优先级\n")
printf("请输入你的选择:")
scanf("%d",&xz)
printf("\n\n")
if(xz==1)
{
printf("你的选择是先来先服务\n")
printf("请输入进程数:")
scanf("%d",&amount)
yihao(amount)
}
else
{
printf("你的选择是优先级\n")
printf("请输入进程数:")
scanf("%d",&amount)
erhao(amount)
}
}
yihao(int amount)
{
int i,j,l,k
struct fcfs f[n]
printf("\n\n")
for(i=0i<amounti++)
{
printf("请输入第 %d 个程序的信息\n",i+1)
printf("进程名 :")
scanf("%d",&f[i].id)
printf("到达时间:")
scanf("%d",&f[i].atime)
printf("运行时间:")
scanf("%d",&f[i].runtime)
}
for(i=0i<amounti++)
{
for(j=0j<amount-i-1j++)
{
if(f[j].atime>f[j+1].atime)
{
l=f[j].atime
f[j].atime=f[j+1].atime
f[j+1].atime=l
k=f[j].id
f[j].id=f[j+1].id
f[j+1].id=k
}
}
}
printf("进程名 开始时间 运行时间 结束时间 \n")
for(i=0i<amounti++)
{
f[i].ftime=f[i].atime+f[i].runtime
printf("%d %d %d %d\n",f[i].id,f[i].atime,f[i].runtime,f[i].ftime)
f[i+1].atime=f[i].ftime
}
zcx()
}
erhao(int amount)
{
int i,j,l,k
struct fcfs f[n]
printf("\n\n")
for(i=0i<amounti++)
{
printf("请输入第 %d 个程序的信息\n",i+1)
printf("进程名 :")
scanf("%d",&f[i].id)
printf("优先级 :")
scanf("%d",&f[i].atime)
printf("运行时间:")
scanf("%d",&f[i].runtime)
}
for(i=0i<amounti++)
{
for(j=0j<amount-i-1j++)
{
if(f[j].atime>f[j+1].atime)
{
l=f[j].atime
f[j].atime=f[j+1].atime
f[j+1].atime=l
k=f[j].id
f[j].id=f[j+1].id
f[j+1].id=k
}
}
}
printf("进程名 优先级 工作时间 \n")
for(i=0i<amounti++)
{
f[i].ftime=f[i].atime+f[i].runtime
printf("%d%d %d \n",f[i].id,f[i].atime,f[i].runtime)
f[i+1].ftime=f[i].ftime+f[i+1].atime
}
zcx()
}
void main()
{
zcx()
}
这是 *** 作系统的作业吧
#include<windows.h>#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>#define N 10
typedef struct node
{
int ID,time
}jobnode
typedef struct Node
{
int ID,avail
}manode
manode machine[N]
jobnode job[N]
manode* Find_min(manode a[],int m)
{
manode* temp=&a[0]
for(int i=1i<mi++)
{
if(a[i].avail<temp->avail)
temp=&a[i]
}
return temp
}
void Sort(jobnode t[],int n)
{
jobnode temp
for(int i=0i<n-1i++)
for(int j=n-1j>ij--)
{
if(job[j].time>job[j-1].time)
{
temp=job[j]
job[j]=job[j-1]
job[j-1]=temp
}
}
}
void main()
{
int n,m,temp
manode* ma
printf("输入作业数目(作业编号按输入顺序处理)\n")
scanf("%d",&n)
printf("输入相应作业所需处理时间:\n")
for(int i=0i<ni++)
{
scanf("%d",&job[i].time)
job[i].ID=i+1
}
printf("输入机器数目(机器编号按输入顺序处理)\n")
scanf("%d",&m)
for(i=0i<mi++)
{
machine[i].ID=i+1
machine[i].avail=0
}
putchar('\n')
if(n<=m)
{
printf("为每个作业分配一台机器,可完成任务!\n")
return
}
Sort(job,n)
for(i=0i<ni++)
{
ma=Find_min(machine,m)
printf("将机器: %d 从 %d ----->%d 的时间段分配给作业: %d\n",ma->ID,ma->avail,ma->avail+job[i].time,job[i].ID)
ma->avail+=job[i].time
}
temp=machine[0].avail
for(i=1i<mi++)
{
if(machine[i].avail>temp)
temp=machine[i].avail
}
putchar('\n')
printf("该批作业处理完成所需加工时间为: %d\n",temp)
}
刚写的，试过了，运行通过．主要运用贪心算法，应该算比较典型的吧，呵呵，该睡觉了，明天还有考试呢，希望对你有帮助！共同进步哈！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）