动态优先级调度算法

一、代码 

//按优先数调度算法实现处理器调度的程序
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

//进程结构体
struct Jc {
	int ID; //进程id
	int prior; //进程优先数
	int runtime; //运行时间
	int totime; //到达时间
	int state; //进程状态 1 - 就绪态  0 - 结束态
};



struct Jc test;

//显示函数,便于查看进程每一步的调度情况
void  show(int num, struct Jc Que[]) {
	printf("----------------------------------------------\n");
	printf("ID\tprior\truntime\ttotime\tstate\n");
	for (int i = 0; i < num; i++) {
		printf("%d\t%d\t%d\t%d\t%d\n", Que[i].ID, Que[i].prior, Que[i].runtime, Que[i].totime, Que[i].state);
	}
	printf("----------------------------------------------\n");
}

//查找函数，查找队列中优先数最大的进程
int max(int num, int arr[], struct Jc Que[]) {	
			printf("就绪队列 现有进程 :");
	for ( int i = 0; i < arr[num]; i++) { 
		if (Que[arr[i]].runtime > 0) {
			printf(" %d ", Que[arr[i]].ID);
		}
	}
	printf("\n");
	int key = arr[0]; //记录优先数最高的进程的在队列中的位置，默认为第1个进程优先数最高

	for (int i = 0; i < arr[num]; i++) {            //遍历进程队列寻找优先数最大的进程，并记录在max中
		//printf("%d的state  %d\n",i,Que[i].state);
		if ( Que[arr[i]].state == 2) {               //state = 2  表示正在运行，此时不需要查找
			//printf("max函数中判断运行的if  %d的state  %d\n",i,Que[i].state);
			return -1;
		}
		if ( Que[key].prior < Que[arr[i]].prior && Que[arr[i]].state == 1 && Que[arr[i]].runtime != 0
		        && Que[key].runtime != 0) {
			key = arr[i];
		}
	}
	if (key == arr[0] && Que[key].runtime == 0) {
		for (int i = 0; i < arr[num]; i++) {
			if ( Que[arr[i]].state == 1 && Que[arr[i]].runtime != 0) {
				key = arr[i];
			}
		}

	}
	return key;
}

int mintotime(int num, struct Jc Que[]) {
	int minto = Que[0].totime;
	for (int i = 0; i < num ; i++) {
		if (minto > Que[i].totime) {
			minto = Que[i].totime;
		}
	}

	return minto;
}

void re(int num, int nowsum, int minto, struct Jc Que[], int arr[]) {
	int nowtime;
	int flag = arr[num];
	int Tflag = flag;
	for (int i = 0; i < num; i++) {
		nowtime = Que[i].totime - minto - nowsum;
		if (nowtime == 0) {
			arr[flag] = i;
			flag++;
		}
	}
	arr[num] = flag;
}

int main() {
	int num;
	int minto;
	int sum = 0; //记录总运行时间
	printf("请输入进程个数：\n");          //用户输入进程个数
	scanf("%d", &num);
	struct Jc Que[num];
	int arr[num + 1];
	arr[num] = 0;      //定义进程控制块队列
	for (int i = 0; i < num; i++) {                  //初始化队列
		printf("请输入第%d个进程的ID号：\n", i + 1);
		scanf("%d", &Que[i].ID);
		Que[i].prior = rand() % 10 + 1;
		Que[i].runtime = rand() % 10 + 1;
		Que[i].totime = rand() % 10 + 1;
		Que[i].state = 1;
	}
	getchar();  //设置间隔，接收到回车时结束输入
	minto = mintotime(num, Que);
	for (int i = 0; i < num; i++) {   //遍历进程队列计算总运行时间
		sum += Que[i].runtime;
		//printf("%d\n",sum);
	}
	printf("           动态优先级调度算法              \n");
	show(num, Que); //显示最初进程控制块队列
	getchar();  //设置间隔，接收到回车时开始调度算法
	for (int j = 0; j < sum; j++) {
		if (arr[num] < num) {
			re(num, j, minto, Que, arr);
		}
		int key = max(num, arr, Que);
		if (key != -1) { //查找到处于就绪态的最大优先级的进程时，设置其运行
			Que[key].state = 2;
			//printf("%d的state  %d\n",key,Que[key].state);
		}
		//printf("j    %d\n",j);
		for (int i = 0; i < num; i++) {
			//printf("i   %d\n",i);
			if (Que[i].state == 2) { //将运行进程的优先级数和运行时间-1，表示已经完成一次对该进程的调度
				Que[i].prior -= 1;
				Que[i].runtime -= 1;
				if (Que[i].runtime == 0) //完成一次调度后，若该进程还需运行时间为0则设置为结束态，不为0则设置为就绪态
					Que[i].state = 0;
				else
					Que[i].state = 1;
				show(num, Que); //显示完成这次调度后进程控制块队列信息
				getchar();  //设置间隔，接收到回车时进入下一次调度
			}
		}
	}
}

二、运行结果

三、题目要求