C语言简易实现操作系统调度算法-操作系统大作业-FCFS、非抢占SJF、响应比HRRN、时间片RR

春荣秋枯
已于 2023-08-21 18:02:40 修改
阅读量446
点赞数 3
文章标签： c语言算法课程设计
于 2023-08-21 17:46:04 首次发布
本文链接：https://blog.youkuaiyun.com/a149068804/article/details/132413483
版权
该博客介绍了用C语言进行课程设计，实现进程调度算法。程序分多个函数模块，有系统初始化、信息显示等功能。阐述了先到先服务、短作业优先、响应比优先和时间片轮转等算法的核心思想，指出实现中算法传递和计算较难。
摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >
整个程序分多个函数模块，实现进程个数、进程信息、各种数据计算、系统循环、检测非法等功能。
系统初始化与输入进程
进程信息显示及算法选择界面打印
核心思想：

①对于先到先服务，只要将各自的到达时间排序即可
②对于短作业优先，因是非抢占式，在正在运行的进程结束后，在就绪队列的进程中查找到达时间 < 当前进程的结束时间，并且在这些进程中找到运行时间最小即可
③对于响应比优先，因也是非抢占，实现原理和短作业基本相同，计算就绪队列中的响应比即可
④对于抢占式的时间片轮转，实现相对麻烦。我的思想是：设置时间片大小后，通过先到先服务的形式，先到的位于就绪队列队头，当前进程运行完时间片大小后，强行使其退出到达就绪队列队尾，其余进程依次推进。
算法思想不难，难的是各种算法的传递和计算，以及多次嵌套。在实现过程中也是屡次错误。
因时间原因，过多的内容和具体的算法不赘述，感兴趣的小伙伴和大佬欢迎一起讨论
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct P
{
	char name[20];             // 进程名称
	int arrivetime;            // 到达时间
	int running_time;          // 运行时间
	int start_time;            // 开始时间
	int done_time;             // 结束时间
	int zztime;                // 周转时间
	float dqzztime;            // 带权周转时间
	float responseratio;       // 响应比
	int remainder_time;        // 剩余时间
}Pro;


void PrintFinish()
{
	printf("\n\t\t\t★★★ 调度已完成 ★★★\n\n\t\t\t ★★★  请继续  ★★★\n\n\n");
	printf("\n\t\t\t"); system("pause");
	printf("\n\n");
}

void PrintProgram(Pro program)
{
	printf("\t进程名称    到达时间    运行时间    开始时间    结束时间    周转时间    带权周转时间    响应比\n");

	printf("\t------------------------------------------------------------------------------------------------\n");

	printf("\t  %s\t\t%d\t   %d\t\t%d\t    %d\t\t%d\t    %.2f\t  %.2f\n", program.name, program.arrivetime, program.running_time, program.start_time, program.done_time, program.zztime, program.dqzztime, program.responseratio);

	printf("\n");
}

void PrintRRProgram(Pro copyReadyProgram, int start_time, int done_time, int rrtime)
{
	printf("\t正在执行进程%s （ 时间片为 %d ）》》》\n", copyReadyProgram.name, rrtime);
	printf("\t------------------------------------------------------------------------------------------------\n");
	printf("\t进程名称    到达时间    运行时间    开始时间    结束时间    剩余时间\n");
	printf("\t------------------------------------------------------------------------------------------------\n");
	printf("\t  %s\t\t%d\t   %d\t\t%d\t    %d\t\t%d\n", copyReadyProgram.name, copyReadyProgram.arrivetime, copyReadyProgram.running_time, start_time, done_time, copyReadyProgram.remainder_time);

	printf("\n");
}

void inputProgram(int pronum, Pro ReadyProgram[])             // 输入进程信息
{
	int l = 1;

	printf("\t输入进程 》》》\n");
	printf("\t------------------------------------------------------------------------------------------------\n");


	for (int i = 0; i < pronum; i++)
	{
		Pro program;

	A1:
		printf("\t请输入第%d个程序的信息 （名称、到达时间、 运行时间，相继输入并回车）\n\t", i + 1);

		scanf_s("%s", program.name, 20);
		printf("\t");

		scanf_s("%d", &program.arrivetime);
		printf("\t");
		if (program.arrivetime <= 100 && program.arrivetime >= 1);

		else
		{
			printf("\n\t！！！输入非法！！！\n\n");
			rewind(stdin);
			goto A1;
		}

		scanf_s("%d", &program.running_time);
		printf("\t");
		if (program.running_time <= 100 && program.running_time >= 1);

		else
		{
			printf("\n\t！！！输入非法！！！\n\n");
			rewind(stdin);
			goto A1;
		}

		ReadyProgram[i] = program;

		ReadyProgram[i].remainder_time = ReadyProgram[i].running_time;

		printf("\n");
	}

	while (l)
	{
		l = 0;
		for (int i = 0; i < pronum - 1; i++)
		{
			for (int j = i + 1; j < pronum; j++)
			{
				if (strcmp(ReadyProgram[i].name, ReadyProgram[j].name) == 0)
				{
					printf("\n\n\t！！！进程%d与进程%d有相同的进程名称，请检查！！！\n\n", i + 1, j + 1);
					printf("\t请重新输入进程%d的名称：", i + 1);
					scanf_s("%s", ReadyProgram[i].name, 20);
					printf("\t请重新输入进程%d的名称：", j + 1);
					scanf_s("%s", ReadyProgram[j].name, 20);

					l = 1;                                // 若有相同的名称，进入判断语句并修改l 值，使进入下一次循环
				}
			}
		}
	}

	printf("\n\n");
}


void PrintReadyPro(int pronum, Pro ReadyProgram[])                     // 打印初始进程信息
{
	printf("\t------------------------------------------------------------------------------------------------\n");
	printf("\t\t进程名称    到达时间    运行时间\n");
	printf("\t------------------------------------------------------------------------------------------------\n");

	for (int i = 0; i < pronum; i++)
	{
		printf("\t\t  %s\t\t%d\t   %d\n", ReadyProgram[i].name, ReadyProgram[i].arrivetime, ReadyProgram[i].running_time);
	}

	printf("\n\n\n");
}


void Menu()                                         // 算法菜单
{
	printf("\t------------------------------------------------------------------------------------------------\n");
	printf("\t----------------------------------------调度算法模拟程序----------------------------------------\n");
	printf("\t请选择一种调度算法：\n");
	printf("\t1、先到先服务（FCFS）\n");
	printf("\t2、短作业优先（SJF）[ 非抢占式 ]\n");
	printf("\t3、响应比优先（HRRN）\n");
	printf("\t4、时间片轮转（RR）\n");
	printf("\t5、退出系统\n");
	printf("\t6、重新输入进程\n");
	printf("\t------------------------------------------------------------------------------------------------\n");
	printf("\n\n\n");
}

void RRMenu()
{
	printf("\t------------------------------------------------------------------------------------------------\n");
	printf("\t----------------------------------------调度算法模拟程序----------------------------------------\n");
	printf("\t请选择一时间片大小：\n");
	printf("\t1、时间片为1\n");
	printf("\t2、时间片为2\n");
	printf("\t3、时间片为3\n");
	printf("\t------------------------------------------------------------------------------------------------\n");
	printf("\n\n\n");
}

void PrintFCFSRunningOrder(int pronum, Pro ReadyProgram[])              // 打印先到先服务执行顺序
{
	printf("\t先到先服务执行顺序 》》》-------------------------------------------------------------------------\n");
	printf("\n");

	printf("\t进程名称    到达时间    运行时间    开始时间    结束时间    周转时间    带权周转时间\n");

	for (int i = 0; i < pronum; i++)
	{
		printf("\t------------------------------------------------------------------------------------------------\n");

		printf("\t  %s\t\t%d\t   %d\t\t%d\t    %d\t\t%d\t    %.2f\n", ReadyProgram[i].name, ReadyProgram[i].arrivetime, ReadyProgram[i].running_time, ReadyProgram[i].start_time, ReadyProgram[i].done_time, ReadyProgram[i].zztime, ReadyProgram[i].dqzztime);

	}

	printf("\t------------------------------------------------------------------------------------------------\n");

	printf("\n\n\n");
}

void PrintSJFRunningOrder(int pronum, Pro ReadyProgram[])              // 打印短作业优先执行顺序
{
	printf("\t短作业优先执行顺序 》》》-------------------------------------------------------------------------\n");
	printf("\n");

	printf("\t进程名称    到达时间    运行时间    开始时间    结束时间    周转时间    带权周转时间\n");

	for (int i = 0; i < pronum; i++)
	{
		printf("\t------------------------------------------------------------------------------------------------\n");

		printf("\t  %s\t\t%d\t   %d\t\t%d\t    %d\t\t%d\t    %.2f\n", ReadyProgram[i].name, ReadyProgram[i].arrivetime, ReadyProgram[i].running_time, ReadyProgram[i].start_time, ReadyProgram[i].done_time, ReadyProgram[i].zztime, ReadyProgram[i].dqzztime);
	}

	printf("\t------------------------------------------------------------------------------------------------\n");

	printf("\n\n\n");
}

void PrintHRRNRunningOrder(int pronum, Pro ReadyProgram[])              // 打印响应比优先执行顺序
{
	printf("\t响应比优先执行顺序 》》》-------------------------------------------------------------------------\n");
	printf("\n");

	printf("\t进程名称    到达时间    运行时间    开始时间    结束时间    周转时间    带权周转时间\n");

	for (int i = 0; i < pronum; i++)
	{
		printf("\t------------------------------------------------------------------------------------------------\n");

		printf("\t  %s\t\t%d\t   %d\t\t%d\t    %d\t\t%d\t    %.2f\n", ReadyProgram[i].name, ReadyProgram[i].arrivetime, ReadyProgram[i].running_time, ReadyProgram[i].start_time, ReadyProgram[i].done_time, ReadyProgram[i].zztime, ReadyProgram[i].dqzztime);
	}

	printf("\t------------------------------------------------------------------------------------------------\n");

	printf("\n\n\n");
}


void PrintRRRunningOrder(int rrpronum, Pro ReadyProgram[])
{
	printf("\t时间片轮转执行顺序 》》》-------------------------------------------------------------------------\n");
	printf("\n");

	printf("\t进程名称    到达时间    运行时间    开始时间    结束时间    剩余时间\n");

	for (int i = 0; i < rrpronum; i++)
	{
		printf("\t------------------------------------------------------------------------------------------------\n");

		printf("\t  %s\t\t%d\t   %d\t\t%d\t    %d\t\t%d\n", ReadyProgram[i].name, ReadyProgram[i].arrivetime, ReadyProgram[i].running_time, ReadyProgram[i].start_time, ReadyProgram[i].done_time, ReadyProgram[i].remainder_time);
	}

	printf("\t------------------------------------------------------------------------------------------------\n");

	printf("\n\n\n");
}

void PrintReadyProgram(int pronum, Pro ReadyProgram[], int WhichNumber)    // 打印运行进程时的就绪队列（结束时间大于到达时间的显示，否则不显示）
{
	printf("\t就绪队列 》》》\n");
	printf("\t------------------------------------------------------------------------------------------------\n");

	for (int i = WhichNumber + 1; i < pronum; i++)
	{
		if (ReadyProgram[i].arrivetime <= ReadyProgram[WhichNumber].done_time)
		{
			printf("\t进程名称    到达时间    运行时间    响应比    剩余运行时间\n");

			printf("\t  %s\t\t%d\t   %d\t    %.2f\t   %d\n", ReadyProgram[i].name, ReadyProgram[i].arrivetime, ReadyProgram[i].running_time, ReadyProgram[i].responseratio, ReadyProgram[i].remainder_time);

			printf("\t------------------------------------------------------------------------------------------------\n");
		}
	}
}

void PrintRRReadyProgram(int num, Pro copyReadyProgram[], int done_time)    // 打印运行进程时的就绪队列（结束时间大于到达时间的显示，否则不显示）
{
	printf("\t就绪队列 》》》\n");
	printf("\t------------------------------------------------------------------------------------------------\n");

	for (int i = 1; i < num; i++)
	{
		if (copyReadyProgram[i].arrivetime <= done_time)
		{
			printf("\t进程名称    到达时间    运行时间    剩余运行时间\n");

			printf("\t  %s\t\t%d\t   %d\t\t   %d\n", copyReadyProgram[i].name, copyReadyProgram[i].arrivetime, copyReadyProgram[i].running_time, copyReadyProgram[i].remainder_time);

			printf("\t------------------------------------------------------------------------------------------------\n");
		}
	}
}


void ArrivetimePaixu(int pronum, Pro ReadyProgram[])                    // 就绪队列中按到达时间排序
{

	for (int i = 0; i < pronum - 1; i++)
	{
		for (int j = i + 1; j < pronum; j++)
		{
			Pro program;
			if (ReadyProgram[i].arrivetime > ReadyProgram[j].arrivetime)
			{
				program = ReadyProgram[i];
				ReadyProgram[i] = ReadyProgram[j];
				ReadyProgram[j] = program;
			}
		}
	}

	for (int i = 0; i < pronum; i++)
	{
		ReadyProgram[i].remainder_time = ReadyProgram[i].running_time;
	}
}


void FCFS(int pronum, Pro ReadyProgram[])                     // 先到先服务
{
	printf("\t----------------------------《《《 先到先服务调度算法（FCFS）》》》-----------------------------\n");

	ReadyProgram[0].responseratio = 1;

	if (pronum >= 2)
	{
		for (int i = 0; i < pronum; i++)
		{
			printf("\t正在执行进程%s 》》》\n", ReadyProgram[i].name);
			printf("\t------------------------------------------------------------------------------------------------\n");

			for (int j = i + 1; j < pronum; j++)
			{
				ReadyProgram[j].responseratio = (ReadyProgram[j].running_time + ReadyProgram[i].done_time - ReadyProgram[j].arrivetime) * 1.0 / (ReadyProgram[j].running_time);
			}

			if ((i > 0 && ReadyProgram[i].arrivetime > ReadyProgram[i - 1].done_time) || (i == 0))
			{
				ReadyProgram[i].start_time = ReadyProgram[i].arrivetime;
				ReadyProgram[i].responseratio = 1;
			}
			else
			{
				ReadyProgram[i].start_time = ReadyProgram[i - 1].done_time;
			}

			ReadyProgram[i].done_time = ReadyProgram[i].start_time + ReadyProgram[i].running_time;
			ReadyProgram[i].zztime = ReadyProgram[i].done_time - ReadyProgram[i].arrivetime;
			ReadyProgram[i].dqzztime = (ReadyProgram[i].zztime * 1.0) / ReadyProgram[i].running_time;

			for (int j = i + 1; j < pronum; j++)
			{
				ReadyProgram[j].responseratio = (ReadyProgram[j].running_time + ReadyProgram[i].done_time - ReadyProgram[j].arrivetime) * 1.0 / (ReadyProgram[j].running_time);
			}

			ReadyProgram[i].remainder_time = 0;

			PrintProgram(ReadyProgram[i]);

			PrintReadyProgram(pronum, ReadyProgram, i);

			printf("\t"); system("pause");
			printf("\n\n");
		}
		PrintFCFSRunningOrder(pronum, ReadyProgram);
	}

	else
	{
		printf("\t------------------------------------------------------------------------------------------------\n");
		printf("\t正在执行进程 》》》\n");
		printf("\t------------------------------------------------------------------------------------------------\n");
		ReadyProgram[0].start_time = ReadyProgram[0].arrivetime;
		ReadyProgram[0].done_time = ReadyProgram[0].start_time + ReadyProgram[0].running_time;
		ReadyProgram[0].zztime = ReadyProgram[0].done_time - ReadyProgram[0].arrivetime;
		ReadyProgram[0].dqzztime = (ReadyProgram[0].zztime * 1.0) / ReadyProgram[0].running_time;

		ReadyProgram[0].remainder_time = 0;
		PrintProgram(ReadyProgram[0]);
	}
	printf("\n\n\n");
}


void SJF(int pronum, Pro ReadyProgram[])
{
	printf("\t---------------------------《《《 短作业优先调度算法（SJF）》》》-------------------------------\n");

	for (int i = 0; i < pronum - 1; i++)                                    // 若到达时间相同，把服务时间小的放在前
	{
		for (int j = i + 1; j < pronum; j++)
		{
			Pro program;
			if (ReadyProgram[i].arrivetime == ReadyProgram[j].arrivetime)
			{
				if (ReadyProgram[i].running_time > ReadyProgram[j].running_time)
				{
					program = ReadyProgram[i];
					ReadyProgram[i] = ReadyProgram[j];
					ReadyProgram[j] = program;
				}
			}
		}
	}

	ReadyProgram[0].start_time = ReadyProgram[0].arrivetime;               // 首进程的开始时间和响应比是确定值
	ReadyProgram[0].responseratio = 1;
	ReadyProgram[0].done_time = ReadyProgram[0].arrivetime + ReadyProgram[0].running_time;

	for (int i = 0; i < pronum; i++)
	{

		if (i > 0)
		{
			for (int j = i + 1; j < pronum; j++)
			{
				Pro program;
				if (ReadyProgram[j].arrivetime <= ReadyProgram[i - 1].done_time && ReadyProgram[j].running_time < ReadyProgram[i].running_time)
				{
					program = ReadyProgram[i];
					ReadyProgram[i] = ReadyProgram[j];
					ReadyProgram[j] = program;
				}
			}

			if (ReadyProgram[i].arrivetime > ReadyProgram[i - 1].done_time)
			{
				ReadyProgram[i].start_time = ReadyProgram[i].arrivetime;
				ReadyProgram[i].responseratio = 1;
			}
			else
			{
				ReadyProgram[i].start_time = ReadyProgram[i - 1].done_time;
				ReadyProgram[i].responseratio = (ReadyProgram[i].running_time + ReadyProgram[i-1].done_time - ReadyProgram[i].arrivetime) * 1.0 / (ReadyProgram[i].running_time);
			}
		}

		printf("\t正在执行进程%s 》》》\n", ReadyProgram[i].name);
		printf("\t------------------------------------------------------------------------------------------------\n");

		ReadyProgram[i].done_time = ReadyProgram[i].start_time + ReadyProgram[i].running_time;
		ReadyProgram[i].zztime = ReadyProgram[i].done_time - ReadyProgram[i].arrivetime;
		ReadyProgram[i].dqzztime = (ReadyProgram[i].zztime * 1.0) / ReadyProgram[i].running_time;

		for (int j = i + 1; j < pronum; j++)
		{
			ReadyProgram[j].responseratio = (ReadyProgram[j].running_time + ReadyProgram[i].done_time - ReadyProgram[j].arrivetime) * 1.0 / (ReadyProgram[j].running_time);
		}

		ReadyProgram[i].remainder_time = 0;
		PrintProgram(ReadyProgram[i]);

		PrintReadyProgram(pronum, ReadyProgram, i);

		printf("\t"); system("\n\tpause");
		printf("\n\n");
	}

	printf("\n");
	PrintSJFRunningOrder(pronum, ReadyProgram);
}


void HRRN(int pronum, Pro ReadyProgram[])
{
	ReadyProgram[0].start_time = ReadyProgram[0].arrivetime;

	ReadyProgram[0].responseratio = 1;

	printf("\t-----------------------------《《《 响应比优先调度算法（HRRN）》》》----------------------------\n");

	for (int i = 0; i < pronum; i++)
	{
		Pro program;

		if (i > 0)
		{
			for (int j = i + 1; j < pronum; j++)
			{
				if (ReadyProgram[j].arrivetime <= ReadyProgram[i - 1].done_time && ReadyProgram[j].responseratio > ReadyProgram[i].responseratio)
				{
					program = ReadyProgram[i];
					ReadyProgram[i] = ReadyProgram[j];
					ReadyProgram[j] = program;
				}
			}
		}

		if ((i > 0 && ReadyProgram[i].arrivetime > ReadyProgram[i - 1].done_time) || (i == 0))
		{
			ReadyProgram[i].start_time = ReadyProgram[i].arrivetime;
			ReadyProgram[i].responseratio = 1;
		}
		else
			ReadyProgram[i].start_time = ReadyProgram[i - 1].done_time;

		ReadyProgram[i].done_time = ReadyProgram[i].start_time + ReadyProgram[i].running_time;
		ReadyProgram[i].zztime = ReadyProgram[i].done_time - ReadyProgram[i].arrivetime;
		ReadyProgram[i].dqzztime = (ReadyProgram[i].zztime * 1.0) / ReadyProgram[i].running_time;

		for (int j = i + 1; j < pronum; j++)
		{
			ReadyProgram[j].responseratio = (ReadyProgram[j].running_time + ReadyProgram[i].done_time - ReadyProgram[j].arrivetime) * 1.0 / (ReadyProgram[j].running_time);
		}

		ReadyProgram[i].remainder_time = 0;
		printf("\t正在执行进程%s 》》》\n", ReadyProgram[i].name);
		printf("\t------------------------------------------------------------------------------------------------\n");
		PrintProgram(ReadyProgram[i]);

		PrintReadyProgram(pronum, ReadyProgram, i);

		printf("\t\t"); system("pause");
		printf("\n\n");
	}

	printf("\n");
	PrintHRRNRunningOrder(pronum, ReadyProgram);
}


void RR(int pronum, Pro ReadyProgram[])
{
	Pro RRReadyProgram[100];
	Pro copyReadyProgram[30];                       // 定义数组，用于最终打印时间片执行顺序的数组


	int rrtime;                                              // 记录选择的时间片
	int rrpronum = 0;                                        // 记录时间片执行顺序的数组的个数
	int num = pronum;                                    // 用于打印已经缩减一个长度的数组

	RRMenu();
	printf("\t\t请选择：");
	scanf_s("%d", &rrtime);
	printf("\n\n");

	while (rrtime != 1 && rrtime != 2 && rrtime != 3)        // 时间片选择输入非法
	{
		printf("\n\t\t！！！输入非法，请重新输入！！！\n\n\t\t");
		rewind(stdin);
		scanf_s("%d", &rrtime);
		RRMenu();
	}

	printf("\t-----------------------------《《《 时间片轮转调度算法（HRRN）》》》----------------------------\n");


	for (int i = 0; i < pronum; i++)
	{
		if ((i > 0 && ReadyProgram[i].arrivetime > ReadyProgram[i - 1].done_time) || (i == 0))
		{
			ReadyProgram[i].start_time = ReadyProgram[i].arrivetime;
		}
		else
			ReadyProgram[i].start_time = ReadyProgram[i - 1].done_time;

		ReadyProgram[i].done_time = ReadyProgram[i].start_time + ReadyProgram[i].running_time;
	}

	int time = ReadyProgram[0].done_time;                                     // 总时间初始化， 为首进程的结束时间

	for (int i = 1; i < pronum; i++)
	{
		if (ReadyProgram[i].arrivetime <= ReadyProgram[i - 1].done_time)                  // 若到达时间 <= 上一进程结束时间， 总时间直接加其运行时间
			time = time + ReadyProgram[i].running_time;
		else if (ReadyProgram[i].arrivetime > ReadyProgram[i - 1].done_time)              // 否则要加上空窗期（在此之间已进行了先到先服务的排序）
			time = time + ReadyProgram[i].running_time + ReadyProgram[i].arrivetime - ReadyProgram[i - 1].done_time;
	}

	for (int i = 0; i < pronum; i++)
	{
		copyReadyProgram[i] = ReadyProgram[i];                            // 复制一份数组
	}

	printf("%d", time);

	int start_time = ReadyProgram[0].arrivetime;
	int done_time = start_time + ReadyProgram[0].running_time;                 // 记录开始时间，结束时间

	while (done_time < time)                                            // 当 a < time 总时间时，循环
	{
		int remainder_time = copyReadyProgram[0].remainder_time;                 // 记录进程运行前的剩余时间
		int x = 0, y = 0;                                                                // 用于判断前后剩余时间是否一致，以此判断进程是否首次运行

		if (remainder_time == copyReadyProgram[0].running_time) { x = 1; }       // 若运行前剩余时间 = 运行时间，x = 1

		copyReadyProgram[0].remainder_time = copyReadyProgram[0].remainder_time - rrtime;

		if (copyReadyProgram[0].remainder_time != copyReadyProgram[0].running_time) { y = 1; }      // 若运行后剩余时间 != 运行时间，y = 1

		if (x && y)                                                               // 满足 x, y 则首次运行，记录其开始时间
		{
			for (int i = 0; i < pronum; i++)
			{
				if (strcmp(ReadyProgram[i].name, copyReadyProgram[0].name) == 0)
					ReadyProgram[i].start_time = start_time;
			}
		}

		Pro program;

		if (copyReadyProgram[0].remainder_time > 0)
		{
			done_time = start_time + rrtime;

			PrintRRProgram(copyReadyProgram[0], start_time, done_time, rrtime);
			PrintRRReadyProgram(num, copyReadyProgram, done_time);

			RRReadyProgram[rrpronum] = copyReadyProgram[0];
			RRReadyProgram[rrpronum].done_time = done_time;
			RRReadyProgram[rrpronum].start_time = start_time;
			rrpronum++;

			for (int i = 0; i < num - 1; i++)
			{
				if (done_time >= copyReadyProgram[i + 1].arrivetime)
				{
					program = copyReadyProgram[i];
					copyReadyProgram[i] = copyReadyProgram[i + 1];
					copyReadyProgram[i + 1] = program;
				}
			}
		}

		else if (copyReadyProgram[0].remainder_time <= 0)
		{
			copyReadyProgram[0].remainder_time = 0;
			done_time = start_time + remainder_time;

			copyReadyProgram[0].done_time = done_time;

			PrintRRProgram(copyReadyProgram[0], start_time, done_time, rrtime);
			PrintRRReadyProgram(num, copyReadyProgram, done_time);

			RRReadyProgram[rrpronum] = copyReadyProgram[0];
			RRReadyProgram[rrpronum].done_time = done_time;
			RRReadyProgram[rrpronum].start_time = start_time;
			rrpronum++;

			for (int i = 0; i < pronum; i++)
			{
				if (strcmp(ReadyProgram[i].name, copyReadyProgram[0].name) == 0)
					ReadyProgram[i].done_time = done_time;
			}

			for (int i = 0; i < num; i++)
			{
				copyReadyProgram[i] = copyReadyProgram[i + 1];
			}

			num = num - 1;
		}

		if (copyReadyProgram[0].arrivetime > done_time) { start_time = copyReadyProgram[0].arrivetime; }
		else { start_time = done_time; }

		printf("\t\t"); system("pause");
		printf("\n\n");
	}

	PrintRRRunningOrder(rrpronum, RRReadyProgram);
	printf("\t\t");

	printf("\t执行结果（ 时间片为 %d ） 》》》\n\n", rrtime);
	printf("\t------------------------------------------------------------------------------------------------\n");
	printf("\t进程名称    到达时间    运行时间    开始时间    结束时间    周转时间    带权周转时间\n");

	for (int i = 0; i < pronum; i++)
	{
		ReadyProgram[i].zztime = ReadyProgram[i].done_time - ReadyProgram[i].arrivetime;
		ReadyProgram[i].dqzztime = (ReadyProgram[i].zztime * 1.0) / ReadyProgram[i].running_time;

		printf("\t------------------------------------------------------------------------------------------------\n");

		printf("\t  %s\t\t%d\t   %d\t\t%d\t    %d\t\t%d\t    %.2f\n", ReadyProgram[i].name, ReadyProgram[i].arrivetime, ReadyProgram[i].running_time, ReadyProgram[i].start_time, ReadyProgram[i].done_time, ReadyProgram[i].zztime, ReadyProgram[i].dqzztime);

		printf("\n");
	}
}

int main()
{
	int t = 1;                                           // 用于选择算法循环
	int pronumber;                                       // 用于记录进程数
	char opt[20] = { 0 };                                // 用于记录选择的算法

	Pro ReadyProgram[30];                               // 创建结构体数组

	printf("\n\t------------------------->>>>>> 欢迎使用操作系统模拟调度算法 <<<<<<-----------------------------\n");
	printf("\t------------------------------------------------------------------------------------------------\n");

A:
	printf("\t请输入进程个数（小于等于30）：");
	scanf_s("%d", &pronumber);

	if (pronumber <= 30 && pronumber >= 1);

	else
	{
		printf("\n\t！！！输入非法！！！\n\n");
		rewind(stdin);
		goto A;
	}

	printf("\n\n\n");

	inputProgram(pronumber, ReadyProgram);                            // 初始化结构体数组函数，即输入进程

	ArrivetimePaixu(pronumber, ReadyProgram);                         // 根据到达时间排序，形成初始就绪队列

	PrintReadyPro(pronumber, ReadyProgram);                           // 打印初始就绪队列     

	while (t)
	{
		Menu();
		printf("\t请选择（请输入序号或名称、简称）：");
		scanf_s("%s", opt, 20);

		printf("\n\n\n");
		if (strcmp(opt, "1") == 0 || _strcmpi(opt, "FCFS") == 0 || strcmp(opt, "先到先服务") == 0)           // 选择先到先服务
		{
			ArrivetimePaixu(pronumber, ReadyProgram);

			FCFS(pronumber, ReadyProgram);

			PrintFinish();
		}

		else if (strcmp(opt, "2") == 0 || _strcmpi(opt, "SJF") == 0 || strcmp(opt, "短作业优先") == 0)      // 选择短作业优先
		{
			ArrivetimePaixu(pronumber, ReadyProgram);

			SJF(pronumber, ReadyProgram);

			PrintFinish();
		}

		else if (strcmp(opt, "3") == 0 || _strcmpi(opt, "HRRN") == 0 || strcmp(opt, "响应比优先") == 0)      // 选择响应比优先
		{
			ArrivetimePaixu(pronumber, ReadyProgram);

			HRRN(pronumber, ReadyProgram);

			PrintFinish();
		}

		else if (strcmp(opt, "4") == 0 || _strcmpi(opt, "RR") == 0 || strcmp(opt, "时间片轮转") == 0)      // 选择响应比优先
		{
			ArrivetimePaixu(pronumber, ReadyProgram);

			RR(pronumber, ReadyProgram);

			PrintFinish();
		}

		else if (strcmp(opt, "5") == 0 || strcmp(opt, "退出") == 0 || strcmp(opt, "退出系统") == 0)			// 选择退出系统，退出循环
		{
			printf("\t！！！退出成功！！！\n\n");
			t = 0;
		}

		else if (strcmp(opt, "6") == 0 || strcmp(opt, "重新输入") == 0 || strcmp(opt, "重新输入进程信息") == 0)    // 选择重新输入进程
		{
			printf("\t------------------------->>>>>> 欢迎使用操作系统模拟调度算法 <<<<<<-------------------------------\n");
			printf("\t------------------------------------------------------------------------------------------------\n");

		B:
			printf("\t请输入进程个数（小于等于30）：");
			scanf_s("%d", &pronumber);

			if (pronumber <= 30 && pronumber >= 1);

			else
			{
				printf("\n\t！！！输入非法！！！\n\n");
				rewind(stdin);
				goto B;
			}
			printf("\n\n\n");

			inputProgram(pronumber, ReadyProgram);                            // 初始化结构体数组函数，即输入进程

			ArrivetimePaixu(pronumber, ReadyProgram);                         // 根据到达时间排序，形成初始就绪队列

			PrintReadyPro(pronumber, ReadyProgram);                           // 打印初始就绪队列
		}

		else                                                                  // 非法输入
		{
			rewind(stdin);
			printf("\t！！！输入非法！！！\n\t--请重新输入，序号或名称、简称--\n\n");
		}
	}


	printf("\t------------------------------------------------------------------------------------------------\n");
	printf("\t-------------------------------------！！！有缘江湖再见！！！------------------------------------\n");
	printf("\t------------------------------------------------------------------------------------------------\n");
};