本文目录一览：
C语言编程实现时间片轮转算法，尽量写得简单易懂，谢谢
#includestdlib.h
#define MAX 5 //进程数量
#define RR 2 //时间片大小
/*时间片轮转算法*/
struct pro
{
int num;
int arriveTime;
int burst;
int rt; //记录进程被运行的次数
struct pro *next;
};
int TOTALTIME; //记录所有进程的总时间
//函数声明
struct pro* creatList();
void insert(struct pro *head,struct pro *s);
struct pro* searchByAT(struct pro *head,int AT);
void del(struct pro* p);
int getCount(struct pro *head,int time);
struct pro* searchEnd(struct pro *head);
void move(struct pro *headF,struct pro *headT,int n);
struct pro* creatList() //创建链表，按照进程的到达时间排列,记录所有进程的信息
{
struct pro* head=(struct pro*)malloc(sizeof(struct pro));
head-next=NULL;
struct pro* s;
int i;
TOTALTIME=0;
for(i=0;iMAX;i++)
{
s=(struct pro*)malloc(sizeof(struct pro));
printf("请输入进程名:\n");
scanf("%d",(s-num));
printf("请输入到达时间:\n");
scanf("%d",(s-arriveTime));
printf("请输入运行时间:\n");
scanf("%d",(s-burst));
TOTALTIME+=s-burst; //计算总时间
s-rt=1; //rt的初始值为1
s-next=NULL;
insert(head,s);
}
return head; //到达队列中的进程按照其到达时间的先后顺序排列
}
void insert(struct pro *head,struct pro *s) //插入节点
{
struct pro *p=searchByAT(head,s-arriveTime);
s-next=p-next;
p-next=s;
return;
}
struct pro* searchByAT(struct pro *head,int AT) //查找第一个到达时间大于等于AT的节点，返回其前一个指针
{
struct pro *p,*q;
p=head;
q=head-next;
while(q!=NULLq-arriveTime=AT)
{
p=q;
q=q-next;
}
return p;
}
void del(struct pro* p) //删除p的下一个节点
{
struct pro *tmp;
tmp=p-next;
p-next=tmp-next;
free(tmp);
return;
}
int getCount(struct pro *head,int time) //察看在time之前到达但未移动到运行队列的进程数量
{
int count=0;
struct pro *s,*t;
s=head;
t=s-next;
while(t!=NULLt-arriveTime=time)
{
s=t;
t=t-next;
count++; //count记录当前时刻到达的进程数
}
return count;
}
struct pro* searchEnd(struct pro *head) //查找并返回循坏队列的尾节点的前一个节点
{
struct pro *p,*q;
p=head;
q=head-next;
while(q-next!=head)
{
p=q;
q=q-next;
}
return p;
}
void move(struct pro *headF,struct pro *headT,int n) //将headF后的n个节点移动到循环队列headT中
{
struct pro *r,*s,*t;
s=headF;
t=s-next;
r=t; //r记录要移动的第一个节点
while(n1)
{
t=t-next;
n--;
}
s-next=t-next; //以上完成从原队列中摘除相关节点,r,t分别为第一个和最后一个节点
s=searchEnd(headT);
t-next=s-next;
s-next=r;
}
void run(struct pro *head)
{
int time=0; //记录当前时间
int newarrive;//新到达进程数
struct pro *runhead=(struct pro*)malloc(sizeof(struct pro));
runhead-next=runhead; //创建新的循环链表，存放当前就绪队列中的进程
struct pro *p,*q;
p=runhead;
q=p-next; //q记录当前应当运行的进程
while(time=TOTALTIME)
{
newarrive=getCount(head,time);
if(newarrive0)
move(head,runhead,newarrive); //将head后的newarrive个节点移动到runhead队列中
if(runhead-next==runhead) //就绪队列中没有进程
time++;
else if(q==runhead)
{
p=q;
q=q-next;
}
else
{
printf("进程名:%d\n",q-num);
printf("到达时间:%d\n",q-arriveTime);
if(q-rt==1)
printf("响应时间:%d\n",time-q-arriveTime);
else
printf("第%d次运行开始时间:%d\n",q-rt,time);
if(q-burst=RR)
{
time+=q-burst;
printf("第%d次运行结束时间:%d\n",q-rt,time);
printf("周转时间:%d\n",time-q-arriveTime);
printf("************************************\n");
struct pro *tmp=q;
q=q-next;
p-next=q;
free(tmp);
}
else //q-burstRR
{
time+=RR;
printf("第%d次运行结束时间:%d\n",q-rt,time);
printf("************************************\n");
q-burst-=RR;
q-rt++;
p=q;
q=q-next;
}
}
}
}
void main()
{
struct pro *head=creatList();
printf("当前时间片大小为:%d\n",RR);
run(head);
}
C语言问题
将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.
短作业优先算法用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语言版)
#includestdio.h
#includestdlib.h
typedef struct process_FCFS{
float arrivetime;//到达时间
float servetime;//服务时间
float finishtime;//完成时间
float roundtime;//周转时间
float daiquantime;//带权周转时间
struct process_FCFS *link;//结构体指针
}FCFS;
FCFS *p,*q,*head=NULL;
struct process_FCFS a[100];
//按到达时间进行冒泡排序
struct process_FCFS *sortarrivetime(struct process_FCFS a[],int n)
{
int i,j;
struct process_FCFS t;
int flag;
for(i=1;in;i++)
{
flag=0;
for(j=0;jn-i;j++)
{
if(a[j].arrivetimea[j+1].arrivetime)
{
t=a[j];
a[j]=a[j+1];
a[j+1]=t;
flag=1;//交换
}
}
if(flag==0)//如果一趟排序中没发生任何交换，则排序结束
break;
}
return a;
}
//先来先服务算法
void print(struct process_FCFS a[],int n)
{
int i;
for(i=0;in;i++)
{
printf("到达时间：%f",a[i].arrivetime);
printf("服务时间：%f",a[i].servetime);
printf("完成时间：%f",a[i].finishtime);
printf("周转时间：%f",a[i].roundtime);
printf("带权周转时间：%f",a[i].daiquantime);
printf("\n");
}
}
void Fcfs(struct process_FCFS a[],int n)
{
int i;
a[0].finishtime=a[0].arrivetime+a[0].servetime;
a[0].roundtime=a[0].finishtime+a[0].arrivetime;
a[0].daiquantime=a[0].roundtime/a[0].servetime;
for(i=0;in;i++)
{
if(a[i].arrivetimea[i-1].finishtime)
{
a[i].finishtime=a[i-1].finishtime+a[i].servetime;
a[i].roundtime=a[i].finishtime-a[i].arrivetime;
a[i].daiquantime=a[i].roundtime/a[i].servetime;
}
else
{
a[i].finishtime=a[i].arrivetime+a[i].servetime;
a[i].roundtime=a[i].finishtime-a[i].arrivetime;
a[i].daiquantime=a[i].roundtime/a[i].servetime;
}
}
printf("先来先服务\n");
print(a,n);
}
//主函数
void main()
{
int n,i;
printf("请输入有几个进程\n");
scanf("%d",n);
for(i=0;in;i++)
{
printf("arrivetime");
scanf("%f",a[i].arrivetime);
printf("servetime");
scanf("%f",a[i].servetime);
}
Fcfs(a,n);
}
