题目：

设RQ分为RQ1和RQ2，RQ1采用轮转法，时间片q=7.
RQ1>RQ2，RQ2采用短进程优先调度算法。
测试数据如下：RQ1: P1-P5, RQ2: P6-P10　
进程 P1 P2 P3 P4 P5 P6 P7 P8 P9 P10
运行时间 16 11 14 13 15 21 18 10 7 14
已等待时间 6 5 4 3 2 1 2 3 4 5
实现描述：
typedef struct tag_pcb
{ char name[8];
int need;//须运行的时间
int turn;//周转时间
struct tag_pcb *next;
} PCB;
PCB * RQ1,*RQ2，*Finish;
int clock=0; //时钟
main ( )
{ 输入RQ1；
输入RQ2；（最好从文件读入）
while（ＲＱ１！＝ＮＵＬＬ）
｛ 从RQ1中选取一进程Pi准备运行；
计算其运行的时间t;
clock+=t; //表示Pi运行t;
if (Pi完成） 计算其turn;
否则 Pi加入到队尾；
}
while（ＲＱ2!＝ＮＵＬＬ）
{ 从RQ2中选取一进程Pi准备运行；
clock+=Pi.need;
计算Pi的turn;
}
输出进程的周转时间；
}

一、 题目描述：

实现多级队列调度算法，进程一实现轮转法，时间片为7，进程二采用最短进程优先算法。输出需要运行的时间和周转时间，利用clock标记记录单进程运行的时间。掌握轮转调度算法和短进程优先掉调度算法，并对两种算法进行简单分析。

二、 程序功能及设计思路：

（1）功能：
1、 实现轮转调度算法和短进程优先算法。
2、 输出进程的开始时间、结束时间、运行周期、等待时间等。
（2）设计思路
1、 利用list建立两个就绪队列RQ1,RQ2,并建立一个进程信息结构体包含进程名字、运行时间、周期等信息。
2、 设计两个创建队列函数createRQ1、createRQ2, 进行进程信息的初始化，利用push_back函数将信息压占栈。
3、 设计轮转法和短进程优先算法，并将相关进程信息输出。

#include<iostream>
#include<list>
#define capacity 7
using namespace std;

struct PCB {
	string name;
	int needtime;//进程运行所需时间
	int starttime;//进程开始运行的时间
	int endtime;//进程结束运行的时间 
	int first_starttime;//第一次开始运行的时间
	int runtime;//已经运行的时间
	int waittime;//已等待时间
	int count;//运行次数
};


list<PCB> RQ1, RQ2;
int clock=0;//系统时间
string _name[10]={ "P1","P2","P3","P4","P5","P6","P7","P8","P9","P10" };
int _needtime[10] = { 16,11,14,13,15,21,18,10,7,14 };
int _waittime[10] = { 6,5,4,3,2,1,2,3,4,5 };

void creatRQ1() {
	for (int i = 0; i < 5; i++) {
		PCB p1;
		p1.name = _name[i];
		p1.needtime = _needtime[i];
		p1.waittime = _waittime[i];
		p1.runtime = 0;
		p1.endtime = 0;
		p1.first_starttime = 0;//为了计算周转时间，turn=结束时间减去第一次执行时间
		p1.starttime = 0;
		p1.count = 0;
		RQ1.push_back(p1);
	}
	cout << "创建进程：\t" << "执行所需时间：\n";
	list<PCB>::iterator it;
	for (it = RQ1.begin(); it != RQ1.end(); it++) {
		cout << it->name << "\t\t" << it->needtime << endl;
	}
}

void creatRQ2() {
	for (int i = 5; i < 10; i++){
		PCB p2;
		p2.name = _name[i];
		p2.needtime = _needtime[i];
		p2.waittime = _waittime[i];
		p2.runtime = 0;
		p2.count = 0;
		p2.first_starttime = 0;
		p2.starttime = 0;
		p2.endtime = 0;
		RQ2.push_back(p2);
	}
	cout << "创建进程：\t" << "进程执行所需时间:\n";
	for (list<PCB>::iterator it = RQ2.begin(); it != RQ2.end(); it++) {
		cout << it->name << "\t\t" << it->needtime << endl;
	}
}


void RR() {
	cout << "--------------------轮转法--------------------" << endl;
	creatRQ1();
	clock = 0;
	cout << "进程：\t" << "执行还需时间\t" << "开始执行时间\t" << "执行次数\t" << "已执行时间\t"\
		<< "结束时间：\t" << "周转时间：\n";
	while (!RQ1.empty()) {
		PCB* p = &RQ1.front();//返回第一个元素变量的引用
		p->starttime = clock;
		cout << p->name << "\t\t" << p->needtime << "\t\t" << p->starttime << "\t\t";
		if (p->needtime > capacity) {
			clock += capacity;
			(p->count)++;
			p->runtime += capacity;
			p->needtime -= capacity;
			if (p->count == 1)
				p->first_starttime = p->starttime;
			cout << p->count << "\t\t" << p->runtime << "\t\t\t\t" << endl;
			RQ1.push_back(*p);
			RQ1.pop_front();
		}
		else {
			clock += p->needtime;
			(p->count)++;
			p->runtime += p->needtime;
			p->needtime = 0;
			p->endtime = clock;
			if (p->count == 1)
				p->first_starttime = p->starttime;
			cout << p->count << "\t\t" << p->runtime << "\t\t" << p->endtime << "\t\t" << p->endtime - p->first_starttime << "\t\t"\
				<< "执行完毕";
			RQ1.pop_front();
		}
	}
	cout << endl;
}

/*bool cmp(PCB a,PCB b){
	return a.needtime < b.needtime ;
}*/

void SPPSM() {
	cout << "--------------------短进程优先调度法--------------------\n";
	creatRQ2();
	clock = 0;
	cout << "进程：\t" << "执行所需时间：\t" << "开始执行时间：\t" << "结束时间：\t" << "周转时间\n";
	while (!RQ2.empty()) {
		list<PCB>::iterator p = RQ2.begin();
		for (list<PCB>::iterator it = RQ2.begin(); it != RQ2.end(); it++) {
			//找到最短预计执行的时间
			if (it->needtime < p->needtime)
				p = it;
		}
		p->starttime = clock;
		p->endtime = p->starttime + p->needtime;
		clock = p->endtime;
		cout << p->name << "\t\t" << p->needtime << "\t\t" <<p->starttime<<"\t\t"<< p->endtime << "\t\t" << p->endtime - p->starttime << "\t执行完毕\n";
		RQ2.erase(p);
	}
}

int main() {
	RR();
	SPPSM();
}

运行结果