C语言优先级短进程调度算法对于分号和小数点作为间隔符的实现

短作业(进程)优先调度算法

系统对于短进程或者作业进行调度，当有若干进程进入系统后，系统从队列中选择一个个或者是若干个来进行作业调度进程调度，当前进程运行完后接着寻找下一个最短时间的进程进行调度。

优先级调度算法

优先级调度算法的类型
系统对于进程进行优先级上的划分，以此来对进程进行调度。当最高游戏机的进程运行完之后，系统自动调用后被队列中的优先级最高的进程来进行调用。

对于调度算法中进程的执行顺序，来进行周转时间和带权周转时间上的计算：
结束时间=开始时间+服务/执行时间
周转周期=结束时间-到达时间
带权周转时间=周转时间/服务时间

优先级

对于第一个进程的筛选，优先级通过输入的优先级别进行选择，即除了第一个到达系统的进程可以首先运行，在第一个进程运行中到达系统的进程都需要进行优先级的排序来运行，且不可抢占
首先对于系统中的进程从开头设置while循环来进行筛选

while ((j

然后根据优先级别的高低来进行进程的首位筛选有无同一时刻到达的进程调用

if (process[j].priority>process[i].priority)
{
max_priority=process[j].priority;
i=j;
}
j++;


通过进程的运行时间和到达时间来算出第一个进程结束的时间后，再进行下一个进程的筛选（这里用的是分号的运算方式，后面会提到分号和小数点的运算方式的区别）此时之前调用的进程中被标记为以调用，并且表示调用进程代码向下自增

process[number_schedul].flag=1;//改程序已经运行一次所以运行标记修改为1
temp_time_hour=process[number_schedul].end_time_hour;//改时间作为结束时间 参与当下一程序进入后 检测下一程序 是否在上一个程序运行结束前进入
temp_time_min=process[number_schedul].end_time_min;
process[number_schedul].order=1;//该进程的运行序列被排为第1个
temp_counter=1;//继续往该（最高优先级）进程下面检索下一个次于它的优先级进程
while (temp_counter{
max_priority=0;
for(j=0;j {
if((process[j].come_time_hour {
if (process[j].priority>max_priority) //检测该进程的优先级要大于当前进程优先级
{
max_priority=process[j].priority;//进程替换，优先级改变
number_schedul=j;
}
}
else if((process[j].come_time_hour=temp_time_hour)&&(process[j].come_time_min<=temp_time_min)&&(!process[j].flag))
{
if (process[j].priority>max_priority) //检测该进程的优先级要大于当前进程优先级
{
max_priority=process[j].priority;//进程替换，优先级改变
number_schedul=j;
}
}
}


在这里表示一点
number_schedul为正在执行的进程编号,
temp_counter已经调度完成的进程个数。
之后继续进行下个进程的开始时间以及运行时间的叠加以此类推，直到所有进程都被调用完。

最短进程

在筛选第一个进程的时候，最短进程考虑的是如何查询出运行时间最短的进程，首先先筛选出同一时刻到达的进程并且进行运行时间上的对比

while ((j {
if (process[j].run_time {
run_time=process[j].run_time;
i=j;
}
j++;
}


当筛选出第一个进进程之后，进行算法上的运行（在下面会说到）运行完后系统则要判断并筛选出在第一个进程时间运行完内到达的进程，并且筛选出下一个最短的进程，此时第一个进程被标记为以调用。

for(j=0;j {
if((process[j].come_time_hour {
run_time=process[j].run_time;
number_schedul=j;
break;
}
else if((process[j].come_time_hour=temp_time_hour)&&(process[j].come_time_min<=temp_time_min)&&(!process[j].flag))
{
run_time=process[j].run_time;
number_schedul=j;
break;
}
}


最后完成最短进程算法的调用

对于时间上的输入，我们往往是分为小数点和分号为间隔符的两种。
如12点35可以表示成：12.35或者是12：35所以对于不同的间隔符号所使用的计算方法也会有些差别。
首先创建task_struct结构体，在其中设置好进程所需的属性
struct task_struct
{
int number; /进程编号/
int come_time_hour;/到达时间/
int come_time_min;
int begin_time_hour; /开始运行时间/
int begin_time_min;
int run_time; /运行时间/
int end_time_hour; /运行结束时间/
int end_time_min;
int end_time_mins;
int priority; /优先级/
int order; /运行次序/
int flag; /调度标志/
}process[MAX];

分号时间调度算法

对于分号上的输入首先应该对于到达时间的设置来进行分号前的小时和分号后的分钟的设置：come_time_hour为小时，come_time_min为分钟。

在调度算法运算的过程中首先确保第一个进程开始的时间等于到来的时间

process[number_schedul].begin_time_hour=process[number_schedul].come_time_hour;//第一个进程调度时间等于到来的时间
process[number_schedul].begin_time_min=process[number_schedul].come_time_min;//第一个进程调度时间等于到来的时间


之后开始进行时间上的叠加，即让到达时间加上运行时间，并且确保当分号后面的时间（分钟）超出60分时，进行小时的换算，并且让小时进行自增。
实现代码如下

process[number_schedul].end_time_min=process[number_schedul].begin_time_min+process[number_schedul].run_time;//第一个进程的结束时间等于运行时间加上开始的时间
process[number_schedul].end_time_hour=process[number_schedul].begin_time_hour;
if(process[number_schedul].end_time_min>=60)
{
process[number_schedul].end_time_mins=process[number_schedul].end_time_min;
process[number_schedul].end_time_min = process[number_schedul].end_time_mins-((int)(process[number_schedul].end_time_mins/60)*60);
process[number_schedul].end_time_hour=process[number_schedul].begin_time_hour+(int)(process[number_schedul].end_time_mins/60);
}


在这里面number_schedul代表的是经过筛选后选出的第一个进程的编号。
首先判断process[number_schedul].end_time_min结束时间是否大于60如果是则进行process[number_schedul].end_time_hour小时位置上的累加，同时
process[number_schedul].end_time_min也要进行除60之后的取余操作。其整数位为process[number_schedul].end_time_hour需要自增的数量。
当第一个进程运行完之后进入下一轮的循环，并且此时后被队列进程数量减去第一个进程即将第一个进程标识为已经使用过。

process[number_schedul].flag=1;//改程序已经运行一次所以运行标记修改为1
temp_time_hour=process[number_schedul].end_time_hour;//改时间作为结束时间 参与当下一程序进入后 检测下一程序 是否在上一个程序运行结束前进入
temp_time_min=process[number_schedul].end_time_min;
process[number_schedul].order=1;//该进程的运行序列被排为第1个
temp_counter=1;//继续往该（最高优先级）进程下面检索下一个次于它的优先级进程


之后通过temp_time_hour以及temp_time_min作为下一个进程的开始时间来进行筛选操作，其中应该确保下一个进程的开始时间是在上一个进程的结束时间内开始的所以要写出该条语句

for(j=0;j {
if((process[j].come_time_hour {
if (process[j].priority>max_priority) //检测该进程的优先级要大于当前进程优先级
{
max_priority=process[j].priority;//进程替换，优先级改变
number_schedul=j;
}
}
else if((process[j].come_time_hour=temp_time_hour)&&(process[j].come_time_min<=temp_time_min)&&(!process[j].flag))
{
if (process[j].priority>max_priority) //检测该进程的优先级要大于当前进程优先级
{
max_priority=process[j].priority;//进程替换，优先级改变
number_schedul=j;
}
}
}


来对下一个进程的可运行性进行判断并且进行之后的运行时间开始时间相加操作，一直到后备队列进程运行完毕。

周转时间

在周转时间的运算上，首先当发现某进程到达时间和结束时间的分钟位置运算时小于零，则要在时刻位置上进行换算

int decimal=process[i].end_time_min-process[i].come_time_min;//分钟
int integer=process[i].end_time_hour;//时刻
if(decimal<0)
{
integer-=1;
decimal =process[i].end_time_min-process[i].come_time_min+60;
f1=(integer-process[i].come_time_hour)*60+decimal;
}


若到达时间小于结束时间的分钟位置则不需要进行换算，即周转时间进行正常的加减

else if(decimal>=0)
{
f1=(process[i].end_time_hour-process[i].come_time_hour)*60+(process[i].end_time_min-process[i].come_time_min);
}


f1为周转时间。

小数点时间调度算法

首先在对于进程到达时间的输入上小数点相较于分号而言更容易输入，首要不同的部分在于当开始时间以及运行时间相加时对于小数位置上的换算，
对于小数部分当超过0.6之后自动视为超过60分钟则自动向整数位自增一
同时保留余数作为分钟时刻。

process[number_schedul].begin_time=process[number_schedul].come_time;//第一个进程调度时间等于到来的时间
process[number_schedul].end_time=process[number_schedul].begin_time+process[number_schedul].run_time;//第一个进程的结束时间等于运行时间加上开始的时间
decimal = process[number_schedul].end_time-(int)process[number_schedul].end_time;//小数部分
if(decimal>=0.6)
{
double remainder = decimal-((int)(decimal/0.6)*0.6);
process[number_schedul].end_time=(int)process[number_schedul].end_time+(int)(decimal/0.6)+remainder;
}


之后开始进行时间上的叠加，即让到达时间加上运行时间，并且确保当分号后面的时间（分钟）超出0.6时，进行整数位（小时）的换算，并且让小时进行自增。

周转时间

在最后的周转时间部分上进行相应的改动，当结束时间的小数位小于开始时间时，整数位自减并作为0.6的一个数值对小数部分进行换算，最后得出的小数值则为分钟位置的时间。
double decimal = (process[i].end_time-(int)(process[i].end_time))-(process[i].come_time-(int)(process[i].come_time));//小数部分
int integer=(int)process[i].end_time;
if(decimal<0)
{
integer-=1;
decimal = (process[i].end_time-(int)(process[i].end_time))-(process[i].come_time-(int)(process[i].come_time))+0.6;
f1=integer-(int)process[i].come_time+decimal;
}
else if(decimal>=0)
{
f1=process[i].end_time-process[i].come_time;
}