C语言简单实现进程调度算法

 

实验原理：

 

FCFS：先进先出算法，进程调度按照进程来的先后顺序进行调度，先来的进程先执行，后来的进程后执行。

短进程优先算法：进程调度按照作业的大小，也就是进程需要的服务时间进行调度，当多个进程都需要获得处理机时，服务时间短的进程优先获得处理机。

优先级算法：进程调度按照进程的优先级进行调度，当多个进程阻塞，处理机空闲时选择优先级最高的进程进行分配。

时间片轮转算法：每个进程执行一个时间片单位后释放处理机，由下一个进程继续执行一个时间片单位。进程间轮流获得处理机。

/*
此程序均 假设采用多道OS ，只有进程调度，以及采用非抢占的方式
*/
#include<stdio.h>
#include<stdlib.h>
#pragma warning (disable:4996)
#define MAX 10
int N;   //进程个数
int timeSliceLength; //时间片长短

typedef struct PCB
{
	char proName; //进程名
	int enTime; //进入时间
	int seTime; //服务时间
	int priority; //优先级； 数值越大，优先级越高
	int startTime; //开始时间
	int endTime;//结束时间
	int turn;//周转时间
	int averTurn; //平均周转时间
	//struct PCB* next;
}PCB;

typedef struct NODE
{
	int m;
	struct NODE* next;

}Intt;
//----------排序用到的结构和函数----------
typedef struct
{
	PCB r[MAX+1];
	int length;
}List;

void swap(List* L,int i,int j)
{
	char tempName;
	int tempEntime;
	int tempSEtime;
	int tempPriority;
	int tempStartTime;
	int tempEndTime;
	int tempTurn;
	int tempAverTurn;

	
	tempName= L->r[i].proName ;
	L->r[i].proName  = L->r[j].proName ;
	L->r[j].proName =tempName ;

	tempEntime= L->r[i].enTime ;
	L->r[i].enTime  = L->r[j].enTime ;
	L->r[j].enTime =tempEntime ;

	tempSEtime= L->r[i].seTime ;
	L->r[i].seTime  = L->r[j].seTime ;
	L->r[j].seTime =tempSEtime ;

	tempPriority= L->r[i].priority ;
	L->r[i].priority  = L->r[j].priority ;
	L->r[j].priority =tempPriority ;

	tempStartTime= L->r[i].startTime ;
	L->r[i].startTime  = L->r[j].startTime ;
	L->r[j].startTime =tempStartTime ;

	tempEndTime= L->r[i].endTime ;
	L->r[i].endTime  = L->r[j].endTime ;
	L->r[j].endTime =tempEndTime ;

	tempTurn= L->r[i].turn ;
	L->r[i].turn  = L->r[j].turn ;
	L->r[j].turn =tempTurn ;

	tempAverTurn= L->r[i].averTurn ;
	L->r[i].averTurn  = L->r[j].averTurn ;
	L->r[j].averTurn =tempAverTurn ;

}

//-------------------初始化---------------------
List* init(int m)
{
	List* arr;
	int i;
	i=0;
	arr= (List *)malloc(sizeof(List));
//	arr1=arr2=(PCB*)malloc(sizeof(PCB));
	
	for(i;i<m;i++)
	{
		arr->r[i].proName ='a';
		arr->r[i].enTime =0;
		arr->r[i].seTime =0;
		arr->r[i].priority =0;
		arr->r[i].startTime =0;
		arr->r[i].endTime =0;
		arr->r[i].turn =0;
		arr->r[i].averTurn =0;

	}
	arr->length =0;

	return arr;
}

void creat(int m,List* arr)
{
	int i;
	i=0;
//	arr= (List *)malloc(sizeof(List));
//	arr->length =0;
//	arr1=arr2=(PCB*)malloc(sizeof(PCB));
	
	for(i;i<m;i++)
	{
		
		//arr->r[MAX] =(PCB*)malloc(MAX*sizeof(PCB));
		printf("请输入第%d个进程的信息:\n",i+1);
		scanf("%c%d%d%d",&arr->r[i].proName,&arr->r[i].enTime,&arr->r[i].seTime,&arr->r[i].priority);
		fflush(stdin);
		(arr->length)++;
		//printf("%c,%d,%d,%d\n",arr1->proName,arr1->enTime,arr1->seTime,arr1->priority);
		
		//scanf("%d",&arr->enTime);
	/*	if(i==0)
			arr = arr1;
		else
			arr2->r[i].next = &(arr1->r[i]);
		arr2