实时模拟_非抢占式SJF调度算法

  1 #include
  2 #include
  3 typedef struct course{/*进程结构体*/
  4     char courseName;/*进程名称*/
  5     int startTime/*到达时间*/,serviceTime/*服务时间*/;
  6     int survivalTime/*生存时间*/,WhetherIn/*是否就绪*/;
  7     int destructionTime/*销毁时间*/,readyTime/*就绪时间*/;
  8     struct course*next;
  9 }course;
 10 void typeIn(course*courseData,int n);/*录入进程数据*/
 11 void myQSort(course*courseData,int left,int right);/*按到达时间排序进程数据*/
 12 void output(course*courseData,int n);/*按到达时间升序进程数据后输出*/
 13 void SJFreal_timeSimulation(course*courseData,int n);/*实时模拟SJF进程调度算法*/
 14 void summarize(course*courseData,int n);/*实验总结*/
 15 int main(){
 16     int n;
 17     course courseData[100];
 18     while(1){
 19         system("cls");
 20         printf("模拟实验的进程数量：");
 21         scanf("%d",&n);
 22         system("cls");
 23         typeIn(courseData,n);/*录入进程数据*/
 24         myQSort(courseData,0,n-1);/*按到达时间排序进程数据*/
 25         system("cls");
 26         //output(courseData,n);/*按到达时间升序进程数据后输出*/
 27         SJFreal_timeSimulation(courseData,n);/*实时模拟SJF进程调度算法*/
 28         myQSort(courseData,0,n-1);/*按到达时间排序进程数据*/
 29         summarize(courseData,n);/*实验总结*/
 30         system("pause");
 31     }
 32     return 0;
 33 }
 34 void typeIn(course*courseData,int n){
 35     int i;
 36     for(i=0;i){
 37         printf("进程名称（Char）：");
 38         rewind(stdin);
 39         scanf("%c",&courseData[i].courseName);
 40         printf("到达时间（Int）：");
 41         scanf("%d",&courseData[i].startTime);
 42         printf("服务时间（Int）：");
 43         scanf("%d",&courseData[i].serviceTime);
 44         courseData[i].survivalTime=courseData[i].serviceTime;
 45         courseData[i].WhetherIn=0;
 46         printf("\n");
 47     }
 48 }
 49 void myQSort(course *courseData,int left,int right){
 50     int i=left,j=right;
 51     course key,exchange;
 52     if(i<j){
 53         do{
 54             key=courseData[i];
 55             while(ikey.startTime)
 56                 j--;
 57             if(i<j){
 58                 exchange=courseData[i];
 59                 courseData[i]=courseData[j];
 60                 courseData[j]=exchange;
 61                 i++;
 62             }
 63             while(ikey.startTime)
 64                 i++;
 65             if(i<j){
 66                 exchange=courseData[i];
 67                 courseData[i]=courseData[j];
 68                 courseData[j]=exchange;
 69                 j--;
 70             }
 71         }while(i<j);
 72         courseData[i]=key;
 73         myQSort(courseData,left,i-1);
 74         myQSort(courseData,i+1,right);
 75     }
 76 }
 77 void output(course*courseData,int n){
 78     int i;
 79     printf("按到达时间升序进程数据后输出如下：\n");
 80     printf("序号 进程名称 到达时间 服务时间\n");
 81     for(i=0;i)
 82         printf("%d\t%c\t%d\t%d\n",i+1,courseData[i].courseName,courseData[i].startTime,courseData[i].serviceTime);
 83 }
 84 void SJFreal_timeSimulation(course*courseData,int n){
 85     int i,j,k;
 86     i=k=0;
 87     course *queueF,*queueT,*pre,*p,*m,ans[100];
 88     queueF=queueT=NULL;
 89     while(1){
 90         //printf("当前时间%d：\n",i);
 91         if(queueF){/*本次执行进程*/
 92             if(!queueF->WhetherIn){
 93                 queueF->WhetherIn=1;
 94                 queueF->readyTime=i-1;
 95             }/*
 96             printf("本次执行进程：\n");
 97             printf("进程名称 ：%c\n",queueF->courseName);
 98             printf("到达时间 ：%d\n",queueF->startTime);
 99             printf("服务时间 ：%d\n",queueF->serviceTime);
100             printf("服务开始时间 ：%d\n",queueF->readyTime);
101             printf("已服务时间 ：%d\n",queueF->serviceTime-queueF->survivalTime);
102             printf("剩余服务时间 ：%d\n\n",queueF->survivalTime);*/
103             queueF->survivalTime--;
104         }
105         printf("\n");
106         for(j=0;courseData[j].WhetherIn&&j/*过滤已就绪进程*/
107         for(;j/*本次就绪进程*/
108             if(courseData[j].startTime==i){
109                 /*printf("本次就绪进程：\n");
110                 printf("进程名称 ：%c\n",courseData[j].courseName);
111                 printf("到达时间 ：%d\n",courseData[j].startTime);
112                 printf("服务时间 ：%d\n\n",courseData[j].serviceTime);*/
113                 m=(course*)malloc(sizeof(course));
114                 m->courseName=courseData[j].courseName;
115                 m->survivalTime=m->serviceTime=courseData[j].serviceTime;
116                 m->startTime=courseData[j].startTime;
117                 courseData[j].WhetherIn=1;
118                 m->WhetherIn=0;
119                 if(queueF){
120                     pre=queueF,p=queueF->next;
121                     while(p&&p->serviceTimeserviceTime){
122                         pre=p;
123                         p=p->next;
124                     }
125                     if(p){
126                         m->next=pre->next;
127                         pre->next=m;
128                     }
129                     else{
130                         pre->next=m;
131                         queueT=m;
132                     }
133                 }
134                 else{
135                     queueF=queueT=m;
136                     queueT->next=NULL;
137                 }
138             }
139         if(queueT)
140             queueT->next=NULL;
141         if(queueF&&!queueF->survivalTime){/*本次销毁进程*/
142             ans[k].courseName=queueF->courseName;
143             ans[k].startTime=queueF->startTime;
144             ans[k].serviceTime=queueF->serviceTime;
145             ans[k].readyTime=queueF->readyTime;
146             queueF->destructionTime=ans[k].destructionTime=i;
147             /*printf("本次销毁进程：\n");
148             printf("进程名称 ：%c\n",queueF->courseName);
149             printf("到达时间 ：%d\n",queueF->startTime);
150             printf("服务时间 ：%d\n",queueF->serviceTime);
151             printf("服务开始时间 ：%d\n",queueF->readyTime);
152             printf("服务结束时刻 ：%d\n",i);
153             printf("服务周转时间 ：%d\n",queueF->destructionTime-queueF->startTime);
154             printf("加权周转时间 ：%.2f\n\n",1.0*(queueF->destructionTime-queueF->startTime)/queueF->serviceTime);*/
155             if(queueF==queueT){
156                 free(queueF);
157                 queueF=queueT=NULL;
158             }
159             else{
160                 p=queueF;
161                 queueF=p->next;
162                 free(p);
163             }
164             k++;
165         }
166         if(k==n){
167             for(j=0;j)
168                 courseData[j]=ans[j];
169             return;
170         }
171         i++;
172         //system("pause");
173     }
174 }
175 void summarize(course*courseData,int n){
176     int i;
177     system("cls");
178     printf("实时模拟FCFS进程调度算法结果如下：\n");
179     for(i=0;i){
180         printf("进程名称 ：%c\n",courseData[i].courseName);
181         printf("到达时间 ：%d\n",courseData[i].startTime);
182         printf("服务时间 ：%d\n",courseData[i].serviceTime);
183         printf("服务开始时间 ：%d\n",courseData[i].readyTime);
184         printf("服务结束时刻 ：%d\n",courseData[i].destructionTime);
185         printf("服务周转时间 ：%d\n",courseData[i].destructionTime-courseData[i].startTime);
186         printf("加权周转时间 ：%.2f\n\n",1.0*(courseData[i].destructionTime-courseData[i].startTime)/courseData[i].serviceTime);
187     }
188 }

转载于:https://www.cnblogs.com/KurokoTetsuya/p/3612134.html