实验一 实现单处理机下的进程调度程序

编写一个单处理机下的进程调度程序，模拟操作系统对进程的调度。 要求： 1.能够创建指定数量的进程，每个进程由一个进程控制块表示。 2.实现先来先服务调度算法：进程到达时间可由进程创建时间表示。 3.实现短作业优先调度算法：可指定进程要求的运行时间。（说明：对不可剥夺的短作业优先算法，当作业运行时间相等时，优先调度进程号小的进程执行；对可剥夺式的短作业优先算法，即选最短剩余时间的进程进行运行，在剩余时间相同的情况下，选择到达时间早的进程进行运行） 4. 实现时间片轮转调度算法：可指定生成时间片大小。（说明：新进程到来时插入到就绪队列的队尾，当进程P运行完一个时间片时，若同时有进程Q到达，则先在就绪队列队尾插入新到达的进程Q，之后再插入进程P) 5.实现动态优先级调度算法：可指定进程的初始优先级（优先级与优先数成反比，优先级最高为0），优先级改变遵循下列原则：进程在就绪队列中每停留一个时间片，优先级加1，进程每运行一个时间片，优先级减3。（说明：本算法在优先级相同的情况下，选择到达时间早的进程进行运行） 测试用例格式如下： 输入：调度算法 　　　进程号/到达时间/运行时间/优先级/时间片 输出：调度顺序/进程号/开始运行时间/结束运行时间/优先级 其中调度算法选项为：1----先来先服务，2----短作业优先，3----最短剩余时间优先，4----时间片轮转，5----动态优先级

#include
#include
#include
#include 
#include
#include
using namespace std;

void FIFO（void）;  //先到先服务 
void SJF（）;  //短作业优先
void RR（）;   //时间片轮转 
void SRT（）;  //最短剩余时间  
void DP（）;	 //动态优先级 
void print（void）;
void sort（void）;//到达时间升序排序（冒泡法） 

typedef struct node
{ 
	int id;  //进程号 
	int arrivaltime;  //到达时间 
	int runtime;  // 运行时间
	int prio;  //优先级
	int round;  //时间片
	int flag=1;   //进程是否执行标记 
	bool pushed=false;	//是否推进队列 
	bool done=false;// 是否执行完 
	int order;	//顺序
	int startruntime;	//进程开始运行时间 
	int endruntime;	//进程结束运行时间 
}PCB;//输入进程 

PCB p[50];		//输入进程块 
int p_ptr=0;	//输入进程个数
PCB po[100];		//存放输出的进程块 
int po_ptr;		//输出进程个数 
PCB tab; 
PCB temp; 	 //取队列头，存放于temp中 

int compareArrivaltime（PCB aPCB b） ;
//按进程到达时间升序排序函数
int compareRuntime（PCB aPCB b）;
int comparePriority（PCB a PCB b） ;

int systemtime=0;	//系统时间
queue que;		//定义一个队列存放就绪进程 

int main（） 
{
	int j = 0 k = 0;
	int n ;  //调度算法 
	scanf（“%d“&n）;  //输入是第几个调度算法
	while（scanf（“%d/%d/%d/%d/%d“&p[p_ptr].id&p[p_ptr].arrivaltime
	&p[p_ptr].runtime&p[p_ptr].prio&p[p_ptr].round） == 5）
	{
		p_ptr++;  //每次进程个数加一 
	}
	
	switch（n）
	{
		case 1:
			FIFO（）;  //先到先服务 
			break;
		case 2:  //短作业优先 
		    SJF（）;
			break;
		case 3:
			SRT（）;
			break;
		case 4:
		    RR（）;
			break; 
		case 5:
			DP（）;
			break;
	} 
}
void FIFO（） //先到先服务算法 
{
	sort（）;  //按到达时间从小到大冒泡排序
	//stable_sort（pp+p_ptrcompareArrival） ;
	int i j k;
	po_ptr=p_ptr;//输出数组和输入数组一样大 
	for（j = 0; j < p_ptr; j++）
	{
		po[j].order = j + 1;  //调度顺序 
		po[j].id = p[j].id;  //进程号 
		po[j].prio=p[j].prio;  //优先级 
		if（j == 0）   //最先达到的进程 
		{
			po[j].startruntime = p[j].arrivaltime;
			po[j].endruntime = p[j].runtime+p[j].arrivaltime;
		}
		else 
		{
			if（p[j].arrivaltime			//到了到达时间，此时上一个进程还在执行 
			{
				po[j].startruntime = po[j-1].endruntime;
				po[j].endruntime=po[j-1].endruntime+p[j].runtime;  
			}
			else//到了到达时间，此时上一个进程已结束 
			{
				po[j].startruntime =p[j].arrivaltime;
				po[j].endruntime=p[j].runtime+p[j].arrivaltime;
			}
		}
	}
	print（）;
	
}

void SJF（）//短作业优先 
{
	int jik;
	int flag1=0;//记录开始时间最小的进程号 
	int minarrivaltime=100;
	for（j=0;j	{
	    int minruntime=100;
	    for（i=0;i	    {
	        if（p[i].flag==1&&p[i].arrivaltime			//找出进程最小开始时间 
			{
				minarrivaltime=p[i].arrivaltime;
			}
		}
		while（systemtime		//把系统时间设为进程最小开始时间 
		{
			systemtime++;
		}
		for（i=0;i		{
			if（p[i].flag==1&&p[i].arrivaltime<=systemtime
		    &&p[i].runtime			//选出未执行、当前系统可执行的进程中最短的进程 
			{
				minruntime=p[i].runtime;
				flag1=i;	// 标记最短进程序号 
			}
		}
		p[flag1].flag=0; //进程执行了，flag置为0 
		po[j].order = j + 1;  //调度顺序 
		po[j].id = p[flag1].id;  //进程号 
		po[j].prio=p[flag1].prio;  //优先级 
	    po[j].startruntime=systemtime;//进程开始