时间片轮转算法(C++版)
时间片轮转算法计算公式
时间片轮转算法计算公式时间片轮转算法是一种常见的调度算法,用于操作系统中的进程调度。
它的主要思想是将CPU的执行时间分成若干个时间片,每个进程在一个时间片内得到一定的执行时间,然后被挂起,等待下一个时间片再次执行。
这种算法的优点是公平性好,所有进程都有机会得到执行,缺点是对于I/O密集型的进程效率较低。
在时间片轮转算法中,我们需要计算每个进程在一个时间片内的执行时间,以及每个进程在队列中的等待时间。
这些计算可以通过以下公式来实现:1. 计算每个进程在一个时间片内的执行时间:假设一个时间片的长度为T,进程P_i在一个时间片内的执行时间为E_i,则有:E_i = min(T, R_i)。
其中,R_i表示进程P_i还需要执行的时间。
如果R_i小于T,则进程P_i在一个时间片内执行完毕,执行时间为R_i;如果R_i大于T,则进程P_i在一个时间片内无法执行完毕,执行时间为T。
2. 计算每个进程在队列中的等待时间:假设进程P_i在队列中的等待时间为W_i,则有:W_i = (n-1) T。
其中,n表示进程P_i在队列中的位置。
假设队列中有m个进程,则进程P_i 在队列中的位置为i,因此n = m i + 1。
通过以上两个公式,我们可以计算出每个进程在一个时间片内的执行时间,以及每个进程在队列中的等待时间。
这些计算结果可以帮助操作系统进行进程调度,保证每个进程都能够得到公平的执行机会。
除了上述计算公式,时间片轮转算法还需要考虑一些特殊情况,比如进程在一个时间片内执行完毕的情况,以及新进程的加入等情况。
针对这些情况,我们可以通过适当的调整计算公式来实现。
总之,时间片轮转算法是一种常见的进程调度算法,通过合理的计算公式可以实现对进程执行时间和等待时间的计算,从而保证进程的公平执行。
这些计算公式为操作系统提供了重要的参考,帮助操作系统进行进程调度,提高系统的性能和效率。
时间片轮转算法和优先级调度算法
时间片轮转算法和优先级调度算法-C语言模拟实现-收藏时间片轮转算法和优先级调度算法C语言模拟实现收藏一、目的和要求进程调度是处理机管理的核心内容。
本实验要求用高级语言编写模拟进程调度程序,以便加深理解有关进程控制快、进程队列等概念,并体会和了解优先数算法和时间片轮转算法的具体实施办法。
二、实验内容1. 设计进程控制块PCB的结构,通常应包括如下信息:进程名、进程优先数(或轮转时间片数)、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。
2. 编写两种调度算法程序:优先数调度算法程序循环轮转调度算法程序3. 按要求输出结果。
二、提示和说明分别用两种调度算法对伍个进程进行调度。
每个进程可有三种状态;执行状态(RUN)、就绪状态(READY,包括等待状态)和完成状态(FINISH ),并假定初始状态为就绪状态。
(一)进程控制块结构如下:NAME ----- 进程标示符PRIO/ROUND ――进程优先数/进程每次轮转的时间片数(设为常数2)CPUTIME ――进程累计占用CPU的时间片数NEEDTIME ――进程到完成还需要的时间片数I STATE——进程状态NEXT ――链指针注:2.各进程的优先数或轮转时间片数,以及进程运行时间片数的初值,均由用户在程序运行时给定。
(二)进程的就绪态和等待态均为链表结构,共有四个指针如下:RUN ――当前运行进程指针READY ――就需队列头指针TAIL ――就需队列尾指针FINISH ――完成队列头指针(三)程序说明1. 在优先数算法中,进程优先数的初值设为:50-NEEDTIME每执行一次,优先数减1,CPU时间片数加1,进程还需要的时间片数减1。
在轮转法中,采用固定时间片单位(两个时间片为一个单位),进程每轮转一次,CPU时间片数加2,进程还需要的时间片数减2,并退出CPU,排到就绪队列尾,等待下一次调度。
2. 程序的模块结构提示如下:整个程序可由主程序和如下7个过程组成:(1)INSERT1 ――在优先数算法中,将尚未完成的PCB按优先数顺序插入到就绪队列中;(2)INSERT2 ――在轮转法中,将执行了一个时间片单位(为2),但尚未完成的进程的PCB,插到就绪队列的队尾;(3)FIRSTIN ――调度就绪队列的第一个进程投入运行;(4)PRINT ――显示每执行一次后所有进程的状态及有关信息。
时间片轮转调度算法
// 时间片轮转调度算法#include <iostream>#include <cstdio>#include <cmath>#include <cstring>using namespace std;enum STATUS {RUN,READY,WAIT,FINISH};struct PCBNode{int processID; //进程IDSTATUS status; //进程状态int priorityNum; //优先数int reqTime; //总的需要运行时间int remainTime; //剩下需要运行时间int arriveTime; //进入就绪队列时间int startTime; //开始运行时间int finishTime; //结束运行时间int totalTime; //周转时间float weightTotalTime; //带权周转时间};struct QueueNode{int ID; //进程IDstruct QueueNode * next; //队列中下一个进程指针};struct LinkQueue{QueueNode *head;//队首};void Fcfs(LinkQueue& Q, int& totalTimeSum, int& weightTotalTimeSum,PCBNod e * ProcessT able);bool RR_Run(LinkQueue& Q,QueueNode* q, QueueNode* p, const int Roun d,int& currentTime,PCBNode * ProcessT able);//分配时间片给q所指进程,p为刚退出的进程void RoundRobin(LinkQueue& Q,const int Round, int& totalTimeSum, int& weightTotalTimeSum,PCBNode * ProcessT able);//时间片轮转调度,调用RR_Run(),时间片大小设为Roundvoid InitialQueue(LinkQueue& Q,PCBNode * ProcessT able,const int processnum );//初始化就绪队列void Input(PCBNode * ProcessT able, const int processnum);//从input.txt文件输入数据int main(){LinkQueue Q;//就绪队列Q.head = NULL;const int processnum = 16;//进程数const int Round = 1; //时间片大小int totalTimeSum = 0; //周转时间int WeightTotalTimeSum = 0;//带权周转时间PCBNode * ProcessT able=new PCBNode[processnum]; //进程表Input(ProcessT able, processnum);InitialQueue(Q, ProcessT able, processnum);RoundRobin(Q, Round, totalTimeSum,WeightTotalTimeSum,ProcessT able);cout < < "时间片轮调度的平均周转时间为: " < <totalTimeSum/processnum < <endl;cout < < "时间片轮调度的平均带权周转时间为: " < <WeightTotalTimeSum/processnum < <endl;Input(ProcessT able, processnum);InitialQueue(Q, ProcessT able, processnum);Fcfs(Q, totalTimeSum,WeightTotalTimeSum,ProcessT able);cout < < "先来先服务的平均周转时间为: " < <totalTimeSum/processnum < <endl;cout < < "先来先服务的平均带权周转时间为: " < <WeightTotalTimeSum/processnum < <endl;delete [] ProcessT able;return 0;}void RoundRobin(LinkQueue& Q,const int Round, int& totalTimeSum, int& weightTotalTimeSum,PCBNode * ProcessT able){totalTimeSum = 0; //总的周转时间weightTotalTimeSum = 0;//平均周转时间int currentTime = 0; //当前时间QueueNode* p;QueueNode* q;QueueNode* r;bool finish = false;//调用RR_Run()后,该进程是否已经做完退出p = Q.head;q = p-> next;while (q != NULL)//从队首开始依次分配时间片{do{cout < < "********************** " < <endl;cout < < "在时间片" < <(currentTime+1)/Round < < "内,活动进程为: " < <q-> ID < <endl;cout < < "进程" < <q-> ID < < " 现在需要的时间片为: " < <ProcessT able[q-> ID].remainTime < <endl;finish = RR_Run(Q, q, p, Round, currentTime, ProcessT a ble);//分配时间片给q进程cout < <endl;if (!finish)//若是进程在本时间片内做完,则跳出d o…while循环{if (q-> next == NULL){r = Q.head-> next;}else{r = q-> next;}}else //否则计算周转时间和带权周转时间{totalTimeSum += ProcessT able[q-> ID].totalTime;weightTotalTimeSum += ProcessT able[q-> ID].weightTotalTime;delete q; //从队列中删除q进程q = p;}}while (!finish && (ProcessT able[r-> ID].arriveTime > currentTime + Round));//下一个进程很晚才来,则继续给当前进程分配时间片p = q;q = q-> next;if (q == NULL && Q.head-> next!=NULL){p = Q.head;q = p-> next;}}delete Q.head;Q.head = NULL;}bool RR_Run(LinkQueue& Q,QueueNode* q, QueueNode* p, const int Roun d,int& currentTime,PCBNode * ProcessT able){if (ProcessT able[q-> ID].remainTime <= Round)//在此时间片内能够做完,之后退出进程调度{ProcessT able[q-> ID].finishTime = currentTime + ProcessT able[q-> ID].remainTime;ProcessT able[q-> ID].totalTime += ProcessT able[q-> ID].remainTime;ProcessT able[q-> ID].weightTotalTime = ProcessT able[q-> ID].totalTime/ProcessT able[q-> ID].reqTime;currentTime = ProcessT able[q-> ID].finishTime;p-> next = q-> next;cout < <endl;cout < < "进程" < <q-> ID < < "完成! " < <endl;return true;}else//此时间片内做不完{ProcessT able[q-> ID].remainTime = ProcessT able[q-> ID].remainTime - Round;ProcessT able[q-> ID].totalTime += Round;currentTime += Round;return false;}}void Fcfs(LinkQueue& Q, int& totalTimeSum, int& weightTotalTimeSum,PCBNod e * ProcessT able){totalTimeSum = 0;weightTotalTimeSum = 0;//平均周转时间QueueNode* p;QueueNode* q;p = Q.head-> next;if (p !=NULL ){ProcessT able[p-> ID].startTime = ProcessT able[p-> ID].arriveTime;ProcessT able[p-> ID].finishTime = ProcessT able[p-> ID].arriveTime + ProcessT able[p-> ID].reqTime;}for(q=p-> next; q!=NULL; q=q-> next){if (ProcessT able[q-> ID].arriveTime < ProcessT able[p-> ID].finishTime){ProcessT able[q-> ID].startTime = ProcessT able[p-> ID].finishTime;ProcessT able[q-> ID].finishTime = ProcessT able[p-> ID].finishTime + ProcessT able[q-> ID].reqTime;}else//下个进程到达时间较晚{ProcessT able[q-> ID].startTime = ProcessT able[q-> ID].arriveTime;ProcessT able[q-> ID].finishTime = ProcessT able[q-> ID].arriveTime + ProcessT able[q-> ID].reqTime;}p = q;}for(q=Q.head-> next; q!=NULL; q=q-> next){ProcessT able[q-> ID].totalTime = ProcessT able[q-> ID].finishTime - ProcessT able[q-> ID].arriveTime;ProcessT able[q-> ID].weightTotalTime = ProcessT able[q-> ID].totalTime/ProcessT able[q-> ID].reqTime;totalTimeSum += ProcessT able[q-> ID].totalTime;weightTotalTimeSum += ProcessT able[q-> ID].weightTotalTime;}int t = 0;for(q=Q.head-> next; q!=NULL; q=q-> next){cout < < "********************* " < <endl;while ( t <ProcessT able[q-> ID].finishTime ){cout < < "时刻" < <t < < ": 进程" < <q-> ID < < "活动" < <endl;t++;}if (q-> next != NULL){cout < < "时刻" < <t < < ": 进程" < <q-> ID < < "结束活动,开始下一个进程. " < <endl;cout < < "进程" < <q-> ID < < "的周转时间为: " < <ProcessT able[q-> ID].totalTime < <endl;cout < < "进程" < <q-> ID < < "的带权周转时间为: " < <ProcessT able[q-> ID].weightTotalTime < <endl < <endl;}else{cout < < "时刻" < <t < < ": 进程" < <q-> ID < < "结束活动. " < <endl < <endl;cout < < "进程" < <q-> ID < < "的周转时间为: " < <ProcessT able[q-> ID].totalTime < <endl;cout < < "进程" < <q-> ID < < "的带权周转时间为: " < <ProcessT able[q-> ID].weightTotalTime < <endl < <endl;}}cout < < "所有进程结束活动. " < <endl < <endl;p = Q.head;for(q=p-> next; q!=NULL; q=q-> next){delete p;p = q;}}void InitialQueue(LinkQueue& Q, PCBNode * ProcessT able,const int processn um){//初始化for (int i=0;i <processnum;i++){ProcessT able[i].processID=i;ProcessT able[i].reqTime=ProcessT able[i].remainTime;ProcessT able[i].finishTime=0;ProcessT able[i].startTime=0;ProcessT able[i].status=WAIT;ProcessT able[i].totalTime=0;ProcessT able[i].weightTotalTime=0;}Q.head = new QueueNode;Q.head-> next = NULL;QueueNode * p;QueueNode * q;for (i=0;i <processnum;i++){p = new QueueNode;p-> ID = i;p-> next = NULL;if (i == 0){Q.head-> next = p;}elseq-> next = p;q = p;}}void Input(PCBNode * ProcessT able, const int processnum){FILE *fp; //读入线程的相关内容if((fp=fopen( "input.txt ", "r "))==NULL){cout < < "can not open file! " < <endl;exit(0);}for(int i=0;i <processnum;i++){fscanf(fp, "%d %d %d ",&ProcessT able[i].arriveTime,&ProcessT able[i].remainTime,&ProcessT able[i].priorityNum);}fclose(fp);}建议输入数据:input.txt0 4 01 35 12 10 23 5 36 9 47 21 5 9 35 611 23 712 42 813 1 914 7 10 20 5 1123 3 1224 22 1325 31 1426 1 15。
用c语言实现时间片轮转调度算法
用c语言实现时间片轮转调度算法时间片轮转调度算法是一种常见的进程调度算法,其主要思想是将所有就绪进程按顺序排列,每个进程分配一个时间片,当时间片用尽后,进程被送到队列的末尾,然后下一个进程被执行。
本文将介绍如何使用C语言实现时间片轮转调度算法。
首先,我们需要定义进程控制块(PCB),包括进程的ID、状态、优先级和时间片等信息。
可以使用结构体来表示PCB,代码如下:```typedef struct PCB {int pid; // 进程IDint status; // 进程状态(就绪、运行、等待、结束) int priority; // 进程优先级int time_slice; // 时间片} PCB;```接下来,我们需要创建一个就绪队列和一个等待队列来存储所有进程。
可以使用链表来实现队列,代码如下:```typedef struct Node {PCB *pcb; // PCB指针struct Node *next; // 指向下一个节点的指针} Node;// 就绪队列Node *ready_queue = NULL;// 等待队列Node *wait_queue = NULL;```然后,我们需要编写一个函数来创建进程并添加到就绪队列中。
该函数接受进程的ID、优先级和时间片作为参数,并返回一个指向新进程PCB的指针。
代码如下:```PCB *create_process(int pid, int priority, int time_slice) {PCB *pcb = (PCB*)malloc(sizeof(PCB));pcb->pid = pid;pcb->status = 0; // 就绪状态pcb->priority = priority;pcb->time_slice = time_slice;// 将新进程添加到就绪队列末尾Node *p = (Node*)malloc(sizeof(Node));p->pcb = pcb;p->next = NULL;if (ready_queue == NULL) {ready_queue = p;} else {Node *q = ready_queue;while (q->next != NULL) {q = q->next;}q->next = p;}return pcb;}```接下来,我们需要编写一个函数来模拟时间片轮转调度算法。
操作系统实验时间片轮转
学号P7******* 专业计算机科学与技术姓名陈帅实验日期2017.11.2 教师签字成绩实验报告【实验名称】轮转调度算法【实验目的】1、掌握轮转调度算法。
2、进一步认识如何实现处理器调度。
3、通过对进程调度算法的设计,深入理解进程调度的原理【实验原理】时间片轮转调度算法思想用C语言编程实现,数据结构为队列。
进程等待时间=进程开始运行时间-进程到达时间(即进程处于就绪态时间);进程周转时间=进程结束时间-进程到达时间;加权进程周转时间 = 进程周转时间/进程服务时间;系统平均周转时间=进程周转时间之和/进程数;系统平均带权周转时间=进程带权周转时间之和/进程数。
在分时系统中,最常用的是基于时间片的轮转算法调度算法。
该算法采用了非常公平的处理机分配方式,即让就绪队列上的每个进程每次运行一个时间片。
通过分配时间片的方式让进程获得处理机,若一个时间片未用完,正在运行的程序就已经完成,便将其从就绪队列删除,再调用队首进程,并分配时间片;在一个时间片未用完时,中断程序就会启动,将进程送至就绪队列的尾部。
【数据结构和符号说明】数据结构:struct PCD //定义结构体{char name;//进程名int a_time;//到达时间int s_time;//服务时间int s_time2;int f_time;//完成时间float t_time;//周转时间float wt_time;//带权周转时间int state;//当前进程的状态};符号和函数说明int Currenttime=0;//当前时间PCD s[5];//设置为5个进程queue<PCD> q;//进程队列int turnover(PCD &n)//求周转时间float wturnover(PCD &n)//求带权周转时间程序流程图:程序:#include<iostream>#include<queue>#define MAX 100using namespace std;struct PCD //定义结构体{char name;//进程名int a_time;//到达时间int s_time;//服务时间int s_time2;int f_time;//完成时间float t_time;//周转时间float wt_time;//带权周转时间int state;//当前进程的状态};int Currenttime=0;int turnover(PCD &n)//求周转时间{return n.t_time=n.f_time-n.a_time;}float wturnover(PCD &n)//求带权周转时间{return n.wt_time=n.t_time/n.s_time;}int main(){int t;queue<PCD> q;q=queue<PCD>();PCD s[5];s[0].name='A';//初始化结构体数组s[1].name='B';s[2].name='C';s[3].name='D';s[4].name='E';cout<<"请输入五个进程的到达时间:\n";for(int i=0; i<=4; i++){cout<<s[i].name<<" 到达时间:";cin>>s[i].a_time;s[i].state=i;}cout<<"请输入五个进程的服务时间:\n";for(int i=0; i<=4; i++){cout<<s[i].name<<" 服务时间:";cin>>s[i].s_time;s[i] .s_time2=s[i].s_time;}cout<<"请输入时间片的大小:\n";cin>>t;for(int i=0; i<5-1; i++) //将ABCDE的到达时间升序排列for(int j=0; j<5-1; j++)if(s[j].a_time>s[j+1].a_time)swap(s[j],s[j+1]);q.push(s[0]);//将第一个进程入队列for(int i=1; i<5; i++) //5个都入队列{while(s[i].a_time>Currenttime+t)//当进程到达时间大于当前时间,执行队列中的进程{if(q.empty()==true) //到当前时间Currenttime++;//队列中无进程if(q.empty()!=true) //队列前面有进程 {if(q.front().s_time-t<=0){Currenttime=Currenttime+q.front().s_time;for(int j=0; j<5; j++)if(s[j].state==q.front().state)s[j].f_time= Currenttime;q.pop(); //队列中删除}else{Currenttime=Currenttime+t;q.front().s_time-=t;q.push(q.front());//队头放入队尾q.pop();}}}q.push(s[i]);if(q.front().s_time<=t) //如果有进程提前结束{Currenttime=Currenttime+q.front().s_time;//结束进程 for(int j=0; j<5; j++)if(s[j].state==q.front().state) //设置进程的序号,如果在队列中与进程控制块中匹配s[j].f_time= Currenttime; //终止时间 q.pop();}else{Currenttime=Currenttime+t; //继续执行q.front().s_time-=t;q.push(q.front()); //入队后队头放入队尾q.pop();}}while(q.empty()!=true) //所有进程全部入队 {if(q.front().s_time<=t){Currenttime=Currenttime+q.front().s_time;for(int i=0; i<5; i++)if(s[i].state==q.front().state) //去进程控制块中寻找,改变结束时间s[i].f_time= Currenttime;q.pop();}else{Currenttime=Currenttime+t;q.front().s_time-=t;q.push(q.front());q.pop();}}cout<<" "<<"到达时间 "<<"服务时间 "<<"完成时间 "<<"周转时间 "<<"带权周转时间"<<endl;for(int i=0; i<=4; i++){cout<<s[i].name<<" "<<s[i].a_time<<""<<s[i].s_time2<<" "<<s[i].f_time<<""<<turnover(s[i])<<" ";cout<<wturnover(s[i])<<endl<<endl;//cout是从后往前计算的 }double sum = 0;for(int i = 0; i<5; i++){sum+=s[i].wt_time;}cout<<"此算法平均带权周转时间为"<<sum/5<<endl;return 0;}截图及其说明:在先前定义的5个进程,取名A B C D E输入时间片大小,当时间片为1时,输出如下结果,程序正确输入时间片大小,当时间片为1时,输出如下结果,程序正确。
时间片轮转调度算法实验报告
时间片轮转调度算法实验报告一、引言时间片轮转调度算法是一种常见的操作系统调度算法,它的主要思想是将CPU时间分成若干个时间片,每个进程在一个时间片内执行一定的时间,然后切换到下一个进程执行。
本实验通过使用C语言模拟实现时间片轮转调度算法,并对其进行评估和比较,以便更好地理解该调度算法的性能和特点。
二、实验目的1.理解时间片轮转调度算法的原理和实现方式;2.实现一个简单的时间片轮转调度算法模拟程序;3.比较时间片长度对调度算法性能的影响;4.分析时间片轮转调度算法的优缺点。
三、实验过程1.设计数据结构和算法在开始实验之前,我们首先需要设计数据结构和算法。
在本实验中,我们使用一个队列来表示就绪队列,并使用一个指针来标记当前执行的进程。
2.实现时间片轮转调度算法模拟程序根据设计的数据结构和算法,我们使用C语言编写了一个简单的时间片轮转调度算法模拟程序。
程序首先会要求用户输入进程数量和每个进程的执行时间,然后根据输入的信息,使用时间片轮转调度算法对进程进行调度并统计各个进程的等待时间和周转时间。
3.进行实验和分析我们进行了多组实验,通过改变时间片的长度,观察时间片轮转调度算法的性能。
并对实验结果进行统计和分析,比较不同时间片长度下的平均等待时间和平均周转时间。
四、实验结果和分析在本节,我们将介绍实验的结果和分析。
1.实验结果我们使用不同时间片长度进行了多组实验,得到了如下的结果:时间片长度,平均等待时间,平均周转时间------------,-------------,-------------1,5,152,3,134,2,128,1,112.结果分析通过对实验结果的分析,我们可以得出以下结论:-随着时间片长度的增加,进程的平均等待时间和平均周转时间都呈现下降的趋势。
这是因为时间片越长,每个进程执行的时间就越长,进程切换的次数就越少,从而提高了系统的效率。
-当时间片长度较小时,进程的平均等待时间和平均周转时间较长。
时间片轮转调度算法
时间片轮转调度算法时间片轮转调度算法是一种用于处理多道程序的调度算法,它按照时间片的大小将CPU的使用权交给不同的进程。
这种算法的基本思想是每个进程被分配一个时间段,称为时间片。
当时间片用完时,操作系统会将当前进程挂起,然后将CPU的控制权交给下一个进程。
时间片轮转调度算法可以确保所有的进程都有机会执行,并且不会让一些进程独占CPU资源。
时间片轮转调度算法的实现非常简单。
在这种算法中,操作系统维护一个就绪队列,其中存放了所有等待执行的进程。
操作系统按照队列中进程的先后顺序分配CPU的使用权,每个进程被分配一个固定大小的时间片。
当一个进程的时间片用完时,操作系统将其放入就绪队列的末尾,并将CPU的使用权交给下一个进程。
除了公平性,时间片轮转调度算法还具有响应快的特点。
由于每个进程都只能执行一个固定大小的时间段,因此当一个进程被挂起时,操作系统会立即将CPU的控制权转移到下一个进程,从而减少了响应时间。
然而,时间片轮转调度算法也存在一些缺点。
首先,如果时间片设置得太小,会导致进程切换频繁,从而增加了操作系统的开销。
而如果时间片设置得太大,又可能出现一些进程运行时间过长的情况,造成其他进程长时间等待。
另外,时间片轮转调度算法对于长时间运行的进程来说,可能不够高效。
如果一个进程需要执行的时间超过了时间片的大小,那么它会被挂起并放入就绪队列的末尾,然后进程切换到下一个进程执行。
然而,当这个进程再次被调度时,它需要重新加载状态等信息,这将导致一些额外的开销。
为了解决这个问题,可以使用动态调整时间片大小的方法。
例如,可以根据进程的优先级来调整时间片的大小,优先级较高的进程可以分配更长的时间片,从而提高其执行效率。
同时,为了进一步提高系统的性能,还可以使用多级反馈队列调度算法,根据进程的历史行为调整时间片的大小。
总的来说,时间片轮转调度算法是一种简单且公平的调度算法,适用于多道程序环境下的进程调度。
它的实现简单,但需要合理地设置时间片的大小,以平衡系统的响应时间和效率。
c语言时间片轮转调度代码
时间片轮转调度算法是一种操作系统进程调度算法,它是先进先出(FIFO)调度算法的一种改进版本。
以下是一个用C语言实现的时间片轮转调度算法的简单示例:```c#include <stdio.h>#include <stdlib.h>#define QUANTUM 2 // 定义时间片长度#define PROCESSES 5 // 定义进程数量// 进程结构体typedef struct {int process_id;int arrival_time;int burst_time;int remaining_time;int finished;} Process;// 初始化进程队列void init_processes(Process *processes, int processes_num) {for (int i = 0; i < processes_num; i++) {processes[i].process_id = i + 1;processes[i].arrival_time = i % 5 + 1;processes[i].burst_time = 5;processes[i].remaining_time = processes[i].burst_time;processes[i].finished = 0;}}// 时间片轮转调度void round_robin(Process *processes, int processes_num) {int time = 0;int finished_processes = 0;while (finished_processes < processes_num) {for (int i = 0; i < processes_num; i++) {if (processes[i].arrival_time <= time && !processes[i].finished) { if (processes[i].remaining_time > QUANTUM) {processes[i].remaining_time -= QUANTUM;printf("Time %d: Process %d is running\n", time, processes[i].process_id);} else {processes[i].finished = 1;finished_processes++;printf("Time %d: Process %d is finished\n", time, processes[i].process_id);}}}time++;}}int main() {Process processes[PROCESSES];init_processes(processes, PROCESSES);round_robin(processes, PROCESSES);return 0;}```这个示例中,我们定义了一个进程结构体,包括进程ID、到达时间、运行时间、剩余时间和是否完成。
c语言实现基于时间片轮转调度算法
c语言实现基于时间片轮转调度算法以下是基于时间片轮转调度算法的C语言实现示例:```c#include <stdio.h>#include <stdlib.h>typedef struct Process {int pid; // 进程IDint burstTime; // 执行时间int remainingTime; // 剩余执行时间int arrivalTime; // 到达时间int waitingTime; // 等待时间} Process;void timeSliceScheduling(Process processes[], int n, int timeSlice) {int currentTime = 0;int completedProcesses = 0;while (completedProcesses < n) {for (int i = 0; i < n; i++) {if (processes[i].remainingTime > 0) {int executionTime = (processes[i].remainingTime > timeSlice) ? timeSlice : processes[i].remainingTime;processes[i].remainingTime -= executionTime;currentTime += executionTime;if (processes[i].remainingTime == 0) {completedProcesses++;processes[i].waitingTime = currentTime - processes[i].arrivalTime - processes[i].burstTime;}}}}}void printWaitingTime(Process processes[], int n) { printf("Process\tWaiting Time\n");for (int i = 0; i < n; i++) {printf("%d\t%d\n", processes[i].pid, processes[i].waitingTime);}}int main() {int n, timeSlice;printf("Enter the number of processes: ");scanf("%d", &n);Process processes[n];printf("Enter the burst time and arrival time for each process:\n");for (int i = 0; i < n; i++) {processes[i].pid = i + 1;printf("Process %d: ", processes[i].pid);scanf("%d%d", &processes[i].burstTime,&processes[i].arrivalTime);processes[i].remainingTime = processes[i].burstTime;processes[i].waitingTime = 0;}printf("Enter the time slice: ");scanf("%d", &timeSlice);timeSliceScheduling(processes, n, timeSlice);printWaitingTime(processes, n);return 0;}```这个示例演示了如何使用时间片轮转调度算法计算进程的等待时间。
时间片轮转代码
时间片轮转代码时间片轮转是一种操作系统调度算法,它将CPU的使用权按照时间片分配给不同的进程,以便让每个进程都有机会占用CPU资源。
下面将介绍一份基于C语言实现的时间片轮转代码。
一、算法原理时间片轮转算法的基本思想是将所有就绪队列中的进程按照先来先服务(FCFS)的原则排成一个队列,然后每个进程被分配一个固定长度的时间片,在这个时间片内,该进程可以占用CPU资源执行任务。
当一个进程用完了它分配到的时间片后,操作系统会将它放回到就绪队列末尾,并且把CPU资源交给下一个就绪队列中的进程。
二、代码实现1. 定义结构体为了方便对进程进行管理,我们需要定义一个结构体来存储每个进程的信息,包括PID(进程ID)、burst_time(运行时间)、waiting_time(等待时间)和turnaround_time(周转时间)等。
```struct process {int pid;int burst_time;int waiting_time;int turnaround_time;};```2. 定义主函数在主函数中,我们首先需要输入要调度的进程数和每个进程需要执行的时间。
然后我们可以根据这些信息创建一个结构体数组,并初始化其中每个进程的PID和运行时间。
接下来,我们需要定义一些变量来跟踪当前时间、当前进程和就绪队列等信息。
```int main() {int n, quantum, i, j;struct process p[10];int wt = 0, tat = 0, total_wt = 0, total_tat = 0;printf("Enter the number of processes: ");scanf("%d", &n);printf("Enter the time quantum: ");scanf("%d", &quantum);for (i = 0; i < n; i++) {printf("Enter burst time for process %d: ", i + 1);scanf("%d", &p[i].burst_time);p[i].pid = i + 1;}```3. 实现时间片轮转算法在时间片轮转算法中,我们需要使用一个循环来不断地执行就绪队列中的进程,直到所有进程都执行完毕。
基本时间片轮转调度算法
基本时间片轮转调度算法时间片轮转调度算法是一种常见的进程调度算法,主要应用于分时系统。
在这种算法中,每个进程被分配一个时间片(也称为时间量或量子),在这个时间片结束后,系统将切换到下一个就绪队列中的进程。
以下是基本时间片轮转调度算法的主要特点和步骤:特点:* 时间片:* 系统为每个进程分配一个固定长度的时间片,通常为几十毫秒至几百毫秒。
这个时间片是调度的基本单位。
* 循环调度:* 进程按照就绪队列的顺序轮流执行,每个进程执行一个时间片后,切换到下一个就绪队列中的进程。
* 适用于分时系统:* 主要用于分时系统,确保每个用户或任务都能在短时间内得到CPU的执行时间。
步骤:* 初始化:* 初始化系统的就绪队列,将所有就绪进程按照某种规则(如先来先服务)排列。
* 分配时间片:* 为每个就绪进程分配一个时间片,开始调度。
* 进程执行:* 执行当前就绪队列中的进程,执行一个时间片。
* 判断是否完成:* 判断进程是否执行完毕。
如果进程已完成,则从就绪队列中移除;否则,将其放到队列末尾等待下一轮。
* 选择下一个进程:* 选择就绪队列中的下一个进程,分配给它一个时间片,继续执行。
* 循环调度:* 重复执行上述步骤,直到所有进程执行完毕。
优点和缺点:优点:* 公平性:每个进程都有相等的机会获得CPU执行时间,实现公平调度。
* 简单:实现简单,容易理解和管理。
缺点:* 等待时间不确定:如果某个进程需要执行的时间较长,其他进程可能需要等待较长时间才能获得CPU时间。
* 不适用于实时系统:不适用于对响应时间要求较高的实时系统,因为无法保证每个进程都能在规定时间内完成。
时间片轮转调度算法的实现可以根据具体情况进行调整,例如,可以动态调整时间片的大小,以更好地适应系统的需求。
优先级 时间片轮转调度算法
优先级调度算法和时间片轮转调度算法是两种不同的操作系统进程或任务调度算法。
下面我将分别解释这两种算法:
1. 优先级调度算法:
优先级调度算法是一种非抢占式的调度算法,在这种算法中,每个进程被赋予一个优先级,调度器总是选择优先级最高的进程来执行。
如果多个进程具有相同的优先级,则可以按照FCFS (先进先出)的方式进行调度。
这种算法的优点是简单且易于实现,但可能导致某些进程长时间得不到执行,因此公平性较差。
2. 时间片轮转调度算法:
时间片轮转调度算法是一种抢占式的调度算法,在这种算法中,每个进程被分配一个时间片,当进程在执行过程中用完时间片后,调度器将剥夺该进程的CPU并分配给下一个等待的进程。
如果一个进程在时间片用完之前阻塞或完成,调度器将进行特殊处理。
这种算法的优点是公平性较好,每个进程都有机会获得执行,但实现起来相对复杂。
优先级调度算法和时间片轮转调度算法各有优缺点,适用于不
同的场景。
在实际应用中,操作系统通常会根据具体需求选择适合的调度算法。
实验一 时间片轮转进程调度算法
实验一时间片轮转进程调度算法时间片轮转是一种常用的进程调度算法,它的基本思想是将CPU的使用时间分成若干个时间片,每个进程在一个时间片内运行一段时间。
当一个时间片用完后,就将当前进程放入就绪队列的末尾,然后选择就绪队列中的下一个进程来执行。
下面是一个简单的时间片轮转算法的实验:1. 首先,定义一个进程结构体,包括进程ID、执行时间、剩余时间等属性。
```c++struct Process {int id; // 进程IDint executionTime; // 执行时间int remainingTime; // 剩余时间Process(int id, int executionTime) {this->id = id;this->executionTime = executionTime;this->remainingTime = executionTime;}};```2. 定义一个就绪队列,用于存放所有待执行的进程。
```c++queue<Process> readyQueue;```3. 定义一个时间片大小,例如设为1。
```c++int timeSlice = 1;```4. 创建一些进程,并将它们加入就绪队列。
```c++Process p1(1, 5);Process p2(2, 3);Process p3(3, 2);Process p4(4, 4);readyQueue.push(p1);readyQueue.push(p2);readyQueue.push(p3);readyQueue.push(p4);```5. 开始执行进程调度。
```c++while (!readyQueue.empty()) {Process currentProcess = readyQueue.front(); // 获取当前要执行的进程readyQueue.pop(); // 从就绪队列中移除当前进程// 执行当前进程,更新剩余时间if (currentProcess.remainingTime > timeSlice) {currentProcess.remainingTime -= timeSlice;readyQueue.push(currentProcess); // 将剩余时间不为0的进程重新放入就绪队列} else {currentProcess.remainingTime = 0;cout << "进程" << currentProcess.id << "执行完毕。
时间片轮转调度算法实验报告
******************************************** 测试数据2:2 3 11 2 35 4 2测试数据3:【结论】(结果)测试数据1的运行结果(截图):测试数据2的运行结果:测试数据3的运行结果:源程序代码:#include"stdio.h"#include"stdlib.h" struct stud{错误分析:链表初始化排序过程中:指针p=Null时,不能执行q->arrive等命令;错误解决方法:将while(q->arrive<p->arrive &&q){t=q;q=q->next;}改为:while(q&&q->arrive<p->arrive){t=q;q=q->next;}2、进程运行时间大于时间片时,程序进入死循环:当进程所需时间等于时间片时,运行结果正确:进程运行时间大于时间片时,程序进入死循环:错误分析:进程所需剩余时间计算错误;错误修改:即进入死循环。
当进程所需时间小于时间片时,应立即跳出进程就绪对列。
错误修改:在output()子函数中p->rest=p->rest-slice;后面加上一个语句:if(p->rest<0)p->rest=0;实验运行结果为:实验的体会及收获:通过这次试验,我对处理机的调度算法---基于时间片轮转调度算法思想有了更深的理解;另外使我对链表的知识有了更深的理解,而且锻炼了我的思维能力,使我能更全面地思考问题,以后还需要多做些这方面的练习。
实验还需改进之处:为考虑进程所需时间小于时间片大小的情况,如:进程运行完一次时间片时间中断后,但下一个进程的提交时间要迟很多,这时候就会浪费很多时间等待,这是该程序还需改进的地方。
另外,本实验中的RR算法的时间片大小固定,所以实际是属于基本轮转法,还有种是时间片长短是变化的,即改进轮转法。
时间片轮转调度算法
时间片轮转调度算法时间片轮转(RR)调度算法是专门为分时系统设计的。
它类似于FCFS调度,但是增加了抢占以切换进程。
该算法中,将一个较小时间单元定义为时间量或时间片。
时间片的大小通常为10~100ms。
就绪队列作为循环队列。
CPU调度程序循环整个就绪队列,为每个进程分配不超过一个时间片的CPU。
为了实现RR调度,我们再次将就绪队列视为进程的FIFO队列。
新进程添加到就绪队列的尾部。
CPU调度程序从就绪队列中选择第一个进程,将定时器设置在一个时间片后中断,最后分派这个进程。
接下来,有两种情况可能发生。
进程可能只需少于时间片的CPU执行。
对于这种情况,进程本身会自动释放CPU。
调度程序接着处理就绪队列的下一个进程。
否则,如果当前运行进程的CPU执行大于一个时间片,那么定时器会中断,进而中断操作系统。
然后,进行上下文切换,再将进程加到就绪队列的尾部,接着CPU调度程序会选择就绪队列内的下一个进程。
不过,采用RR策略的平均等待时间通常较长。
假设有如下一组进程,它们在时间0到达,其CPU执行以ms计:P2 3P3 3如果使用4ms的时间片,那么P1会执行最初的4ms。
由于它还需要20ms,所以在第一个时间片之后它会被抢占,而CPU就交给队列中的下一个进程。
由于P2不需要4ms,所以在其时间片用完之前就会退出。
CPU接着交给下一个进程,即进程P3。
在每个进程都得到了一个时间片之后,CPU又交给了进程P1以便继续执行。
因此,RR调度结果如下:现在,我们计算这个调度的平均等待时间。
P1等待10-4=6ms,P2等待4ms,而P3等待7ms。
因此,平均等待时间为17/3=5.66ms。
在RR调度算法中,没有进程被连续分配超过一个时间片的CPU (除非它是唯一可运行的进程)。
如果进程的CPU执行超过一个时间片,那么该进程会被抢占,并被放回到就绪队列。
因此,RR调度算法是抢占的。
如果就绪队列有n个进程,并且时间片为q,那么每个进程会得到1/n的CPU时间,而且每次分得的时间不超过q个时间单元。
处理器调度 时间片轮转法 实验报告(C和C 含源代码)
for(i=0;i<num;i++)
{
printf("\n mp;p[i].name
,p[i].priority
,p[i].time
,p[i].state);
}
printf("********************************************\n");
printf("\n 进程执行完成\n");
%d
%d
%c\n"
,&p[i].name
,p[i].priority
,p[i].time
,p[i].state);
}
printf("********************************************\n");
printf(" 按任意键继续执行:\n");
getchar();//等待输入回车符
把五个进程按顺序排成循环队列,用指针指出队列连接情况。另用一标志单
元记录轮到运行的进程。例如,当前轮到 P2 执行,则有:
标志单元 K2
K1
Q1
K2
2
1
R
PCB1
K2
Q2
K3
3
0
R
PCB2
K3
Q3
K4
1
0
R
PCB3
K4
Q4
K5
2
0
R
PCB4
K5
Q5
K1
4
0
R
PCB5
处理器调度总是选择标志单元指示的进程运行。由于本实验是模拟处理器调
void run(PCB *p)//进程运行子程序 {
时间片轮转算法及优先级调度算法C语言模拟实现收藏
时间片轮转算法及优先级调度算法C语言模拟实现收藏时间片轮转算法是一种常见的CPU调度算法,通过将进程按照到达顺序放置在一个就绪队列中,并且给予每个进程相同的时间片,当进程用完时间片后,将其放到队列的尾部,轮流执行其他进程。
优先级调度算法是根据进程的优先级来决定下一个执行的进程。
下面是使用C语言模拟实现时间片轮转算法和优先级调度算法的代码:```c#include <stdio.h>typedef structchar name[10];int arrivalTime;int burstTime;int remainingTime;} Process;int totalTurnaroundTime = 0;int totalWaitingTime = 0;//初始化每个进程的剩余执行时间for (int i = 0; i < numProcesses; i++)processes[i].remainingTime = processes[i].burstTime;}while (1)int allProcessesFinished = 1; // 标记所有进程是否执行完毕for (int i = 0; i < numProcesses; i++)if (processes[i].remainingTime > 0)allProcessesFinished = 0; // 还有未执行完毕的进程processes[i].remainingTime = 0;} else}printf("%s执行完毕,剩余时间:%d\n", processes[i].name, processes[i].remainingTime);}}if (allProcessesFinished)break; // 所有进程执行完毕,退出循环}}//计算平均周转时间和平均等待时间float averageTurnaroundTime = (float)totalTurnaroundTime / numProcesses;float averageWaitingTime = (float)totalWaitingTime / numProcesses;printf("平均周转时间:%.2f\n", averageTurnaroundTime);printf("平均等待时间:%.2f\n", averageWaitingTime);int maiint numProcesses;printf("请输入进程数量:");scanf("%d", &numProcesses);Process processes[numProcesses];for (int i = 0; i < numProcesses; i++)printf("请输入进程%d的名称、到达时间和执行时间:", i+1);scanf("%s%d%d", processes[i].name, &processes[i].arrivalTime, &processes[i].burstTime);}printf("请输入时间片大小:");return 0;```优先级调度算法:```c#include <stdio.h>typedef structchar name[10];int arrivalTime;int burstTime;int priority;int waitingTime;int turnaroundTime;} Process;void runPriority(Process* processes, int numProcesses)int totalWaitingTime = 0;int totalTurnaroundTime = 0;//对进程按照到达时间进行排序for (int i = 0; i < numProcesses; i++)for (int j = 0; j < numProcesses-i-1; j++)if (processes[j].arrivalTime > processes[j+1].arrivalTime) Process temp = processes[j];processes[j] = processes[j+1];processes[j+1] = temp;}}}processes[0].waitingTime = 0;//计算每个进程的等待时间和周转时间for (int i = 1; i < numProcesses; i++)processes[i].waitingTime = processes[i-1].waitingTime + processes[i-1].burstTime;processes[i].turnaroundTime = processes[i].waitingTime + processes[i].burstTime;totalWaitingTime += processes[i].waitingTime;totalTurnaroundTime += processes[i].turnaroundTime;}//计算平均等待时间和平均周转时间float averageWaitingTime = (float)totalWaitingTime / numProcesses;float averageTurnaroundTime = (float)totalTurnaroundTime / numProcesses;printf("平均等待时间:%.2f\n", averageWaitingTime);printf("平均周转时间:%.2f\n", averageTurnaroundTime);int maiint numProcesses;printf("请输入进程数量:");scanf("%d", &numProcesses);Process processes[numProcesses];for (int i = 0; i < numProcesses; i++)printf("请输入进程%d的名称、到达时间、执行时间和优先级:", i+1);scanf("%s%d%d%d", processes[i].name,&processes[i].arrivalTime, &processes[i].burstTime,&processes[i].priority);}runPriority(processes, numProcesses);return 0;```通过输入进程的信息,可以计算出使用时间片轮转算法和优先级调度算法的平均等待时间和平均周转时间,从而比较它们的效果。
时间片轮转调度算法
(1)一设计要求:编写一程序,可以创建若干个虚拟进程,并对若干个虚拟进程进行调度,调度策略为时间片轮转。
要求:进程的个数,进程的内容(即进程的功能序列)来源于一个进程序列描述文件,另外调度运行结果输出到一个运行日志文件。
二设计目的:熟悉进程调度、设计内容:1.设计PCB适用于轮转法;2.建立进程队列;三虚拟程序的描述:虚拟指令的格式:操作命令操作时间● C :表示在CPU上计算● I :表示输入● O :表示输出● W :表示等待● H :表示进程结束操作时间代表该操作命令要执行多长时间。
这里假设I/O设备的数量没有限制,I和O 设备都只有一类。
I,O,W三条指令实际上是不占有CPU的,执行这三条指令就应该将进程放入对应的等待队列(INPUT等待队列,OUTPUT等待队列,WAIT等待队列)。
例如有一虚拟程序p1.prc描述如下:C 30O 12C 9I 14H 0................程序部分代码如下:enum InstructionSet {INPUT,OUTPUT,WAIT,HALT,CALC};//指令类class CInstruction{friend class COsTestDlg;friend class PCB;public:CInstruction(){}~CInstruction(){}CInstruction(InstructionSet iid,int rt){m_nInstructionID=iid;m_nRunTime=rt;}private:CInstruction* m_pNextInstruction;//用于链接一个进程的所有指令成为链表(指令序列)int m_nRunTime;//本指令需要运行的时间长度(定时器时间间隔的个数)InstructionSet m_nInstructionID;//指令类型标识};//进程控制块类class PCB{friend class COsTestDlg;public:PCB(){m_nPID=0;m_csProcessName="";m_nRemainedTime=0;//m_pRuningInstruction=NULL;m_pInstructionList=NULL;m_pNextPCB=NULL;}//构造或创建一个进程PCB(int pid,CString pname){m_nPID=pid;m_csProcessName=pname;m_nRemainedTime=0;//m_pRuningInstruction=NULL;m_pInstructionList=NULL;m_pNextPCB=NULL;}~PCB(){CInstruction* pTemp;while(m_pInstructionList){m_pInstructionList=m_pInstructionList->m_pNextInstruction; pTemp=m_pInstructionList;delete pTemp;}}//本进程添加一条指令void AppendInstruction(CInstruction* pInstruction){CInstruction* pTempInstruction;if(m_pInstructionList==NULL){//emptym_pInstructionList=pInstruction;}else{//more than one nodepTempInstruction = m_pInstructionList;while(pTempInstruction->m_pNextInstruction!=NULL) pTempInstruction=pTempInstruction->m_pNextInstruction; pTempInstruction->m_pNextInstruction=pInstruction;}}private:PCB* m_pNextPCB; //进程队列的指针int m_nPID; //进程标识符CString m_csProcessName; //进程名字int m_nRemainedTime; //当前运行指令运行还需要的时间CInstruction* m_pRuningInstruction; //指向正在运行或将要运行的指令CInstruction* m_pInstructionList; //指向本进程的指令序列(线性表)的第一条指令};PCB* m_pReadyPCBs;//就绪队列PCB* m_pBackupReadyPCBs;//后备就绪队列PCB* m_pInputWaittingPCBs;//输入等待队列PCB* m_pOutputWaittingPCBs;//输出等待队列PCB* m_pPureWaittingPCBs;//其他等待队列int m_nTimeSlice;//时间片大小(定时器时间间隔的倍数)void LoadPCBs(CString csFileName);//从文件中加载要试验的进程信息void RemoveProcess(PCB* pPCB);//删除进程void DoSchedule();void RunOneTimeRange(PCB* pPCB,int nTime);//运行一个时间段void TreadWaittingQueue(PCB* pWaittingPCBs);//处理某个等待队列,适时将完成进程移出到后备就绪队列。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
//===================qGetNumber============================= int Queue_c::qGetNumber() {int i; i=((rear-front+QueueNum)%QueueNum); return i; } //==================qGetElem============================== ElemType Queue_c::qGetElem(int i) { if(qEmpty()){cout<<"ERROR!"<<endl;return ERROR;} if(i>qGetNumber()-1) { cout<<"ERROR! there is no "<<i<<",or no "<<i<<" in Queue now"<<endl; return ERROR; } return Q[(front+i)%QueueNum]; } //======================qShowQueue========================== int Queue_c::qShowQueue() {int i; if(qEmpty())return ERROR;
} //int qXChange(int); }; //==================Define of Class Queue_c================================= ==== //===================================================================== ========= class Work_c { Queue_c buf; public: int wCPU(); // ElemType wScan(int &t); int wMakeP(); int wShowBUF(){return buf.qShowQueue();} int wInBUF(int i){return buf.qEnQueue(i);} }; //==================Define of Class Work_c================================== === //===================================================================== ========= /*******************************==main==*************************************** ************* ********************************==proc==*************************************** ************/ void main() { Work_c w; int i; //w.wInBUF(5); // w.wInBUF(3); // w.wInBUF(1); clrscr(); char flag='y'; for(i=0;i<10;i++) { //w.buf.qShowQueue(); w.w);
/************************Class Queue_c**********************************/ //================Queue_c================================ Queue_c::Queue_c() { int i; for(i=0;i<QueueNum;i++)Q[i]=QueuePre; rear=0; front=0; } //=====================qFull=========================== int Queue_c::qFull() { if((rear+1)%QueueNum==front) {//cout<<"Queue is full"<<endl; return OK;} else return ERROR; } //================qEmpty================================ int Queue_c::qEmpty() { if(rear==front) {// cout<<"Queue is Empty"<<endl; return OK; } //endif else return ERROR; } //===============qEnQueue=================================
temp=buf.qDeQueue(); if(temp>0)buf.qEnQueue(temp); return OK; } //======================wScan========================= //ElemType Work_c::wScan(int &t) //{ //int i,m=12; //ElemType temp; //for(i=0;i<buf.qGetNumber();i++) // { // temp=buf.qGetElem(i); // if(temp<m){m=temp;t=i;}//endif // }//endfor // if(m<=0||m>buf.qGetFrontElem())return ERROR;// 如果是负数的话在这里就被拦下来了 , 所 以,传出出去的 m 不可能是负数 //return m; //} //======================wMakeP========================= int Work_c::wMakeP() { int t; t=random(200)%2; if(t){buf.qEnQueue(random(10)+1);return OK;} return ERROR; } //======================================================== /**************************End of Class Work_c*********************************/
#include<iostream.h> #include<stdlib.h> #include <conio.h> const int QueueNum=10; const int QueuePre=-1; const int ERROR=0; const int OK=1; const int TimePiece=1; typedef int ElemType; //head define.................... /*************************************************************/ class Queue_c { ElemType Q[QueueNum]; int front,rear; public: //basic information of the class Queue_c: Queue_c(); int qFull(); int qEmpty(); int qEnQueue(ElemType e); ElemType qDeQueue(); int qGetNumber(); int qGetElem(int); int qShowQueue(); //other functions: ElemType qGetFrontElem(){if(qEmpty()){cout<<"ERROR!"<<endl;return ERROR;}return Q[fro nt];} //int qGetFront(){if(qEmpty()){cout<<"ERROR!"<<endl;return ERROR;}return front;} //ElemType qGetRearElem(){if(qEmpty()){cout<<"ERROR!"<<endl;return ERROR;}return Q[(r ear-1+QueueNum)%QueueNum];} //int qGetRear(){if(qEmpty()){cout<<"ERROR!"<<endl;return ERROR;}return (rear-1+QueueNu m)%QueueNum;} //int qShowAll(); int qDec() { if(qEmpty()){cout<<"ERROR!"<<endl;return ERROR;}//endif Q[front]-=TimePiece; return OK;
if(9==i) { cout<<"Are you want to continue?y/n"<<endl; cin>>flag; if('n'==flag)break;else i=0; clrscr(); }//endif }//endfor } /********************************==END==************************************* **************** *********************************==main==************************************* **************/