操作系统——进程调度管理（先来先服务，最短作业优先 ）

这里的数值我提前赋值好的，没有用到时间库，短作业优先的思路是递归算法，得出作业顺序然后再依次进入cpu，先来先服务按照一般顺序算法即可写出来。

#include <stdio.h> 
#include<string.h>
#include<malloc.h>
#include<stdlib.h>
#include<queue>
#define inf 0x3f3f3f
using namespace std; 

typedef struct node{
   int id; //id号 
   int privilege; //优先权 
   int needt_ime; //需运行的时间 
   int reach_time; //进程到达时间
   float excellent; //响应比 
   int wait_time; //等待时间
   bool isreached; //作业是否已抵达
   int finish_time;
   int zhouzhuan_time;
   int begin_time;
   bool visited;        //作业是否被访问过
}pcb ;
 
 

 
const int MAX_NUM = 10;//最大作业数量 
pcb  pcbs[MAX_NUM];//作业 
//就绪队列
void reset_pinfo(int i){
       pcbs[i].id=0;//id号
          pcbs[i].privilege=0;//优先权
          pcbs[i].needt_ime=0;//需运行的时间
          pcbs[i].reach_time=0;//进程到达的时间 
          pcbs[i].excellent=0.0;//响应比
          pcbs[i].wait_time=0;//等待时间
          pcbs[i].isreached=false;//作业是否已抵达
}
void initial_pcbs() { //初始化所有作业信息 
   for(int i=1;i<MAX_NUM;i++)
   {
          pcbs[i].id=0;//id号
          pcbs[i].privilege=0;//优先权
          pcbs[i].needt_ime=0;//需运行的时间
          pcbs[i].reach_time=0;//进程到达的时间 
          pcbs[i].excellent=0.0;//响应比
          pcbs[i].wait_time=0;//等待时间
          pcbs[i].isreached=false;//作业是否已抵达
      }  
   } 
void reset_pinfo() {
    pcbs[1].id=1;pcbs[1].reach_time=800;pcbs[1].needt_ime=50; pcbs[1].privilege=0;
    pcbs[2].id=2;pcbs[2].reach_time=815;pcbs[2].needt_ime=30; pcbs[2].privilege=1;
    pcbs[3].id=3;pcbs[3].reach_time=830;pcbs[3].needt_ime=25; pcbs[3].privilege=2;
    pcbs[4].id=4;pcbs[4].reach_time=835;pcbs[4].needt_ime=20; pcbs[4].privilege=2;
    pcbs[5].id=5;pcbs[5].reach_time=845;pcbs[5].needt_ime=15; pcbs[5].privilege=2;
    pcbs[6].id=6;pcbs[6].reach_time=900;pcbs[6].needt_ime=10; pcbs[6].privilege=1;
    pcbs[7].id=7;pcbs[7].reach_time=920;pcbs[7].needt_ime=5; pcbs[7].privilege=0;
   
}
//找到达时间最早的进程。输入参数为所有的进程信息及待查找的进程总数，输出为最早到达的进程id。
static int* findearlypcb(pcb pcbs[], int count) {
    int i,j,temp;
    int order[count];
//    int ready[count];
    int * ready;
    ready=(int *)malloc(sizeof(int)*count);
    for(i = 1;i <= count; i++){
         order[i] = pcbs[i].reach_time;
         ready[i] = i;
    }
    //冒泡排序
    for(i = 1; i <= count; i++){//按照到达时间大小排序
        for(j = 1; j <= count-i; j++){
            if(order[j] > order[j+1]){
                temp = order[j];
                order[j] = order[j+1];
                order[j+1] = temp;
                
                temp = ready[j];
                ready[j] = ready[j+1];
                ready[j+1] = temp;
            } 
        }
    /*for(i = 1; i <= count; i++){
        printf("第%d个作业",ready[i]);
        printf("到达时间 --%d,服务时间--%d\n",
            pcbs[ready[i]].reach_time,
            pcbs[ready[i]].needt_ime
            );
       }*/
   }
   //printf("到达最早的进程id：%d\n",pcbs[ready[1]].id);
   return ready;
}

//找执行时间最短的作业。输入参数为所有进程的信息及待查找的作业总数，输出为执行时间最短的进程id
static int* findminpcb(pcb pcbs[],int count,int a[]) //int a[]为数组存放id，数组下标从1开始 
 {
     float avg_waittime,avg_zhouzhuang;
    int i,j,temp;
    int order[count];
    int* ready;
    ready=(int *)malloc(sizeof(int)*count);
    for(i =1;i <= count; i++){
         order[i] = pcbs[a[i]].needt_ime;
        // printf("%d\n",order[i]);
         ready[i] = a[i];
    }
    //冒泡排序
    for(i = 1; i <= count; i++){//按照到达作业执行时间长短排序
        for(j = 1; j <= count-i; j++){
            if(order[j] > order[j+1]){
                temp = order[j];
                order[j] = order[j+1];
                order[j+1] = temp;
                
                temp = ready[j];
                ready[j] = ready[j+1];
                ready[j+1] = temp;
            } 
        }
    //    printf("de:%d",ready[1]);
        
    /*for(i = 1; i <= count; i++){
        printf("第%d个作业",ready[i]);
        printf("到达时间 --%d,服务时间--%d\n",
            pcbs[ready[i]].reach_time,
            pcbs[ready[i]].needt_ime
            );
       }*/
   }
   //printf("执行时间最短的进程id：%d\n",pcbs[ready[1]].id);
  // printf("执行时间最短的进程的时间needt_ime: %d\n",pcbs[ready[1]].needt_ime);
   return ready; 
}

void FCFS(pcb pcbs[],int count){ //先来先服务算法。
printf("开始执行时刻    执行结束时刻    周转时间    等待时间  \n");
    int* ready;
    float totally_wait=0,totally_zhouzhuang=0;
    ready=findearlypcb(pcbs, count);
    for(int i=1;i<=count;i++){
        if(i==1){
                pcbs[ready[i]].begin_time=pcbs[ready[i]].reach_time; //开始执行时刻 
                pcbs[ready[i]].finish_time=pcbs[ready[i]].reach_time+pcbs[ready[i]].needt_ime;//执行结束时刻
                pcbs[ready[i]].zhouzhuan_time=pcbs[ready[i]].needt_ime;//周转时间  
                pcbs[ready[i]].wait_time=0;//等待时间 
        } 
        if(i>1){
            pcbs[ready[i]].begin_time=pcbs[ready[i-1]].finish_time;//开始执行时刻 
            
            if(((pcbs[ready[i]].begin_time+pcbs[ready[i]].needt_ime)%100)/10>=6){
                pcbs[ready[i]].finish_time=pcbs[ready[i]].begin_time+pcbs[ready[i]].needt_ime+40;
            }else{
                pcbs[ready[i]].finish_time=pcbs[ready[i]].begin_time+pcbs[ready[i]].needt_ime;
            }//执行结束时刻 
            //等待时间 
            if((pcbs[ready[i]].begin_time-pcbs[ready[i]].reach_time)<60)
            {
                pcbs[ready[i]].wait_time=(pcbs[ready[i]].begin_time-pcbs[ready[i]].reach_time);
                //printf("%d\n",pcbs[ready[i]].wait_time);
            } 
            
        else if(120<=(pcbs[ready[i]].begin_time-pcbs[ready[i]].reach_time)<160)
            {
                pcbs[ready[i]].wait_time=(pcbs[ready[i]].begin_time-pcbs[ready[i]].reach_time)-40; 
    //    printf("%d\n",pcbs[ready[i]].wait_time);
        }
         if((pcbs[ready[i]].begin_time-pcbs[ready[i]].reach_time)>=160)
        {
                pcbs[ready[i]].wait_time=(pcbs[ready[i]].begin_time-pcbs[ready[i]].reach_time)-80;//等待时间 
        }
         
        pcbs[ready[i]].zhouzhuan_time=pcbs[ready[i]].wait_time+pcbs[ready[i]].needt_ime;//周转时间
    } 
    totally_wait=totally_wait+pcbs[ready[i]].wait_time;totally_zhouzhuang=totally_zhouzhuang+pcbs[ready[i]].zhouzhuan_time;
    printf("  %d  %15d  %12d %12d\n",pcbs[ready[i]].begin_time,pcbs[ready[i]].finish_time,pcbs[ready[i]].zhouzhuan_time,pcbs[ready[i]].wait_time); 
    
 }
    printf("平均等待时间：%f 平均平均时间：%f",totally_wait/count,totally_zhouzhuang/count);
    initial_pcbs(); 
}
int* findNextSJF(pcb j[], int count,int id_one[],int k,int m,int time) {
    int* ready1;int* id;int* id_one_one;
    int t=0,n=1;
    int * ready;
    id_one_one=(int *)malloc(sizeof(int)*count);
    ready=(int *)malloc(sizeof(int)*count);
    id=(int *)malloc(sizeof(int)*count);
    ready1=(int *)malloc(sizeof(int)*count);
    //找出最早进入的进程 
    //ready2=findearlypcb(j,count);//时间最早的进程
    //printf("结束需要时间：%d\n",pcbs[ready2[1]].needt_ime);
//    printf("结束\n");
    if(m==1){
        int time_one=j[id_one[m]].reach_time+j[id_one[m]].needt_ime;
        time=time_one;      
    }  
    m++;
    //printf("%d\n",time);
    //每一次一个进程结束，下一个进程谁进入cpu 
    for(int i = 2;i <= count; i++){
         if(j[i].reach_time<time&&j[i].reach_time!=0){
             ready[n] = i;
             t++;n++;
         } 
    }
    printf("%d\n",t);
    ready1=findminpcb(j,t,ready);//执行时间最短的作业
    //printf("%d\n",pcbs[ready1[1]].needt_ime);
    //算出进程执行完的时刻（时间） 
    time= pcbs[ready1[1]].needt_ime+time; 
    if(((time)%100)/10>=6){
                time=time+40;
            }else{
                time=time;
            }
    //printf("%d\n",time);
    reset_pinfo(ready1[1]);//重置进程信息

id_one[k]=ready1[1];
k++;
//重新计算进程数组 
for(int i=1;i<t;i++){
    int temp=ready1[i+1];
    ready1[i]=temp;
}
t--;
//递归
 int id_one_len = sizeof(id_one)/sizeof(id_one[0]); 
printf(" %d",id_one_len);
if(count!=id_one_len){
    id_one_one=findNextSJF(pcbs,count,id_one,k,m,time);
}

//printf("测试：%d",id_one[2]);    
//返回进程数组 
return  id_one_one;
    
    
    

}
//最短作业优先 
void SJF(pcb pcbs[],int count){
//printf("开始执行时刻    执行结束时刻    周转时间    等待时间  \n");
int* id;
id=(int *)malloc(sizeof(int)*count);
int* id1;
id1=(int *)malloc(sizeof(int)*count);
id[1]={pcbs[1].id};
int k=2,m=1,time=0;
id1=findNextSJF(pcbs,count,id,k,m,time);
for(int i=1;i<=count;i++){
    printf("%0.3d",id1[i]);
}
}

int main() {
    initial_pcbs();
    reset_pinfo();
    int count=7;
    findearlypcb(pcbs,count);
    //findminpcb(pcbs,count);
    FCFS(pcbs,count);
    SJF(pcbs,count);
    return 0;
}