标签：轮转 temp start 队列 need next int 算法 PCB

题目很简单，直接上代码：

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
typedef struct PCB {
	string name;
	int need;    //运行需要的时间
	int turn;    //周转时间
	PCB* next;    //PCB结构体指针
	PCB(string nam,int ned,int tur,PCB*nex) {     //构造函数
		name = nam;
		need = ned;
		turn = tur;
		next = nex;
	}
};

string name1[5] = { "p1","p2","p3","p4","p5" };
string name2[5] = { "p6","p7","p8","p9","p10" };
int time1[5] = { 16, 11,14,13,15 };
int time2[5] = { 21,18,10,7,14 };
int wait1[5] = {6,5,4,3,2};
int wait2[5] = { 1,2,3,4,5 };

//由于RQ1和RQ2采用两种不同的进程调度手段，所以每一个都单独创建一个结构体链表
PCB* RQ1, * RQ2, * finish=NULL;
PCB* one, * two;   //中间临时结点
int clock = 0;   //时钟初始化
int timepice = 7;   //时间片固定为7s

int circle(PCB* temp) {     //轮盘调度算法
	//轮盘调度算法：从链表头部开始遍历，首先计算每个进程需要的时间，如果可以在一个时间片timepice里完成
	//则完成后切换到下一个进程，如果不可以，则将其挪到链表尾，进行下一个进程
	PCB*start = temp;
	PCB*end = start;
	PCB* head = new PCB("a", 0, 0, temp);
	PCB*s = head;
	while (end->next) end = end->next;//用q来标记链表末尾位置
	while (start)
	{
		if (start->need > timepice)
		{
			clock += timepice;    //如果没有运行完该进程则将其挪至队尾
			start->need -= timepice;
			end->next = start;
			start = start->next;
			end = end->next;
			s->next = start;
			end->next = NULL;
		}
		else
		{
			clock += start->need;     //因为有表头指针的讯在 所以可以将始终标记最后一个need=0的结点
			start->need = 0;
			start->turn += clock;
			s = start;
			start = start->next;
		}
	}
	RQ1 = head->next;
	return clock;
}

int shortfirst(PCB* temp) {
	//短进程优先算法：该算法将需要运行的进程按需要运行的时间从小到大排序，先运行所需时间小的,运行完成之后再运行下一个
	//排序,每一次找到一个最小值，反复遍历五遍链表
	int min;   //保存最小值
	PCB* p=temp;   //保存头节点
	for (int i = 0; i < 5; i++) {
		min = p->need;
		while (temp != NULL) {     //遍历列表找最小值
			if (min > temp->need) {
				min = temp->need;
				temp = temp->next;
			}
			else { temp = temp->next; }
		}
		temp = p;   //归还头节点
		while (temp->need != min) {
			temp = temp->next;
		}
		clock += temp->need;
		temp->turn += clock;
		temp->need = 99999;   //将上一个最小结点的值置为无穷大  以免后续再次寻找最小值时找同一个结
		temp = p;
	}
	temp = p;   //归还头节点
	return clock;
}


int main() {
	RQ1 =new PCB(name1[0],time1[0],wait1[0],NULL);  //创建一个结点
	PCB* p = RQ1;
	for (int i = 1; i < 5; i++) {
		one = new PCB(name1[i], time1[i], wait1[i], NULL);
		p->next = one;
		p = p->next;     //将RQ1挪到中间结点后继承这个结点
	}
	RQ2 = new PCB(name2[0], time2[0], wait2[0], NULL);  //创建一个结点
	PCB* q = RQ2;
	for (int i = 1; i < 5; i++) {
		two = new PCB(name2[i], time2[i], wait2[i],NULL);
		q->next = two;
		q = q->next;
	}

	clock = circle(RQ1);   //RQ1采用轮转算法
	cout << "RQ1队列采用轮转算法,其中每个进程等待的时间为:" << endl;
	for (int i = 0; i < 5; i++) {
		cout << "P" << i << ": " << RQ1->turn << endl;
		RQ1 = RQ1->next;
	}

	clock = shortfirst(RQ2);   //RQ2采用短进程优先算法
	cout << "RQ2队列采用段进程优先算法,其中每个进程等待的时间为:" << endl;
	for (int i = 6; i < 11; i++) {
		cout << "P"<<i<<": "<<RQ2->turn << endl;
		RQ2 = RQ2->next;
	}
	return 0;
}

因为最后我只输出了turn的时间，如果那个need的时间也需要输出自己稍微加一行代码就可以啦！

标签：轮转,temp,start,队列,need,next,int,算法,PCB
来源： https://blog.csdn.net/weixin_46120503/article/details/115439788

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。