作業調度算法c語言代碼,c語言實現作業調度

本文目錄一覽：

• 1、編寫代碼實現作業的三種調度算法
• 2、短作業優先算法用c語言如何寫?
• 3、求一份兒C語言優先級調度算法要求如下
• 4、操作系統的作業，用C語言模擬先來先服務的方法的進程調度，請大神幫忙看看我這個代碼有什麼問題
• 5、求進程調度先來先服務算法，短進程優先算法完整c語言代碼
• 6、急求 程序代碼 c/c++ 操作系統中的 處理機調度算法

編寫代碼實現作業的三種調度算法

#includewindows.h

#includeiostream

#includestdio.h

#includestring

using namespace std;

const int maxnum=100;

int N; /*進程數*/

double start[maxnum],endtime[maxnum],arrive[maxnum],runtime[maxnum],zhou[maxnum];

double averagezhou; // 平均周轉時間

double average_zhou; //平均帶權周轉時間

char name; //進程名

double dqzhou[maxnum]; //帶權周轉時間

typedef struct node

{

char name[10]; //進程名

int round; //進程時間輪轉時間片

int cputime; //進程佔用CPU時間

int needtime; //進程到完成還要的時間

char state; //進程的狀態

struct node *next; //鏈指針

}PCB;

PCB *finish,*ready,*tail,*run; /*隊列指針*/

void firstin() /*將就緒隊列中的第一個進程投入運行*/

{

run=ready; /*就緒隊列頭指針賦值給運行頭指針*/

run-state=’R’; /*進程狀態變為運行態*/

ready=ready-next; /*就緒對列頭指針後移到下一進程*/

}

void print1(PCB *q) /*進程PCB輸出*/

{

printf(“進程名 已運行時間 還需要時間 時間片 狀態\n”);

printf(” %-10s%-15d%-10d%-10d %-c\n”,q-name,q-cputime,q-needtime,q-round,q-state);

}

void print() /*輸出函數*/

{

PCB *p;

if(run!=NULL) /*如果運行指針不空*/

print1(run); /*輸出當前正在運行的PCB*/

p=ready; /*輸出就緒隊列PCB*/

while(p!=NULL)

{

print1(p);

p=p-next;

}

p=finish; /*輸出完成隊列的PCB*/

while(p!=NULL)

{

print1(p);

p=p-next;

}

}

void insert(PCB *p2) //輪轉法插入函數

{

tail-next=p2; //將新的PCB插入在當前就緒隊列的尾

tail=p2;

p2-next=NULL;

}

void create() /*創建進程PCB*/

{

PCB *p;

int i,time;

char na[10];

ready=NULL;

finish=NULL;

run=NULL;

printf(“請輸入進程名稱和所需要CPU的時間:\n”);

for(i=1;i=N;i++)

{

p=(PCB *)malloc(sizeof(PCB));

scanf(“%s”,na);

scanf(“%d”,time);

strcpy(p-name,na);

p-cputime=0;

p-needtime=time;

if(i==1)

p-state=’R’;

else

p-state=’W’;

p-round=1; /*時間片*/

if(ready!=NULL)

insert(p);

else

{

p-next=ready;

ready=p;

tail=p;

}

}

printf(“——————————————————————\n”);

print(); /*輸出進程PCB信息*/

run=ready; /*將就緒隊列的第一個進程投入運行*/

ready=ready-next;

run-state=’R’;

}

void RR() //時間片輪轉調度

{

while(run!=NULL)

{

run-cputime=run-cputime+1;

run-needtime=run-needtime-1;

if(run-needtime==0) /*運行完將其變為完成態，插入完成隊列*/

{

run-next=finish;

finish=run;

run-state=’F’;

run=NULL;

if(ready!=NULL)

firstin(); /*就緒對列不空，將第一個進程投入運行*/

}

else

if(ready!=NULL) /*如就緒隊列不空*/

{

run-state=’W’; /*將進程插入到就緒隊列中等待輪轉*/

insert(run);

firstin(); /*將就緒對列的第一個進程投入運行*/

}

printf(“——————————————————————\n”);

print(); /*輸出進程信息*/

}

}

void FCFS(double *arrive,double *runtime,double n) //先來先服務調度算法

{

start[0]=arrive[0]; //開始執行時間=到達時間

endtime[0]=start[0]+runtime[0]; //完成時間=開始時間+服務時間

zhou[0]=endtime[0]-arrive[0]; //周轉時間=完成時間-到達時間

dqzhou[0]=zhou[0]/runtime[0];

for(int i=0;in;i++)

{

if(endtime[i-1]arrive[i]||endtime[i-1]==arrive[i])

endtime[i]=endtime[i-1]+runtime[i];

else

endtime[i]=arrive[i]+runtime[i];

zhou[i]=endtime[i]-arrive[i];

dqzhou[i]=zhou[i]/runtime[i];

averagezhou+=zhou[i];

average_zhou+=dqzhou[i];

}

averagezhou=averagezhou/n;

average_zhou=average_zhou/n;

cout”完成時間為:”endl;

for(int j=0;jn;j++)

coutendtime[j]” “endl;

cout”周轉時間為:”endl;

for(int k=0;kn;k++)

coutzhou[k]” “endl;

cout”帶權周轉時間為:”endl;

for(int m=0;mn;m++)

coutdqzhou[m]” “endl;

cout”平均周轉時間為:”endl;

coutaveragezhou” “endl;

cout”平均帶權周轉時間為:”endl;

coutaverage_zhou” “endl;

}

void SJF(double *arrive,double *runtime,double n) //短作業優先調度算法

{

int end[maxnum]; //用於標記進程是否已經執行，應經執行end[i]=1,否則為0;

for(int k=0;kn;k++)

end[k]=0;

int temp,now=0,next=1,p=1; //now表示剛執行完的進程號，next表示下一個要執行的進程號

start[0]=arrive[0]; //開始執行時間=到達時間

endtime[0]=start[0]+runtime[0]; //完成時間=開始時間+服務時間

zhou[0]=endtime[0]-arrive[0]; //周轉時間=完成時間-到達時間

dqzhou[0]=zhou[0]/runtime[0]; //帶權周轉時間=周轉時間/服務時間

averagezhou=zhou[0];

average_zhou=dqzhou[0];

end[now]=1; //執行完的進程設置為1；

for(int i=1;in;i++)

{

int j;

for(j=1;jn;)

{

if(arrive[j]endtime[now]||arrive[j]==endtime[now])

j++;

else

break;

}

temp=j;

int min=p;

for(j=1;j=temp;j++)

{

if(runtime[min]runtime[j] end[j]==0)

min=j;

}

next=min;

endtime[next]=endtime[now]+runtime[next];

zhou[next]=endtime[next]-arrive[next];

dqzhou[next]=zhou[next]/runtime[next];

averagezhou+=zhou[next];

average_zhou+=dqzhou[next];

end[next]=1;

now=next;

next=p;

while(end[p]!=0)

p++;

}

averagezhou=averagezhou/n;

average_zhou=average_zhou/n;

cout”完成時間為:”endl;

for(int j=0;jn;j++)

coutendtime[j]” “endl;

cout”周轉時間為:”endl;

for(k=0;kn;k++)

coutzhou[k]” “endl;

cout”帶權周轉時間為:”endl;

for(int m=0;mn;m++)

coutdqzhou[m]” “endl;

cout”平均周轉時間為:”endl;

coutaveragezhou” “endl;

cout”平均帶權周轉時間為:”endl;

coutaverage_zhou” “endl;

}

int EDF() //最早截止時間的調度算法

{

int arrive_A,arrive_B; //標記進程A,進程B的到達時間

int zhouqi_A,zhouqi_B,serve_A,serve_B; //進程的周期時間和服務時間

int i,j,a=0,b=0,ka=0,kb=0; //ka,kb為開關,i,j,a,b為進程下標

int num_a=0,num_b=0; //服務累計時間

printf(“輸入進程A的周期時間,服務時間: “);

scanf(“%d%d”,zhouqi_A,serve_A);

printf(“輸入進程B的周期時間,服務時間: “);

scanf(“%d%d”,zhouqi_B,serve_B);

for(int T=0;T=100;T++)

{

if(num_a==serve_A) //進程A完成

{

num_a=serve_A+1;

printf(“當T=%d時”,T);

printf(“進程A%d結束\n”,a);

if(num_bserve_B)

{

printf(” 調用進程B%d\n”,b);

kb=1;

}

ka=0;

}

if(num_b==serve_B)

{

num_b=serve_B+1;

printf(“當T=%d時”,T);

printf(“進程B%d結束\n”,b);

if(num_aserve_A)

{

printf(” 調用進程A%d\n”,a);

ka=1;

}

kb=0;

}

if(T%zhouqi_A==0 T%zhouqi_B==0)

{

arrive_A=arrive_B=T;

j=++a;

i=++b;

printf(“當T=%d時,進程A%d和進程B%d同時產生，此時，”,T,j,i);

if(zhouqi_A=zhouqi_B)

{

printf(“調用進程A%d，阻塞進程B%d\n”,j,i);

ka=1;

kb=0;

}

else

{

printf(“調用進程B%d，阻塞進程A%d\n”,i,j);

ka=0;

kb=1;

}

num_a=num_b=0;

}

if(T%zhouqi_A==0T%zhouqi_B!=0)

{

arrive_A=T;

printf(“當T=%d時”,T);

printf(“進程A%d產生 “,++a); //不可能與進程A競爭處理器

num_a=0;

if(num_bserve_B) //進程B沒有完成

if(arrive_B+zhouqi_Barrive_A+zhouqi_A) //若進程B最早截止時間大於進程A的,則執行進程A

{

printf(“進程A%d執行。\n”,a);

ka=1;

kb=0;

}

else //若進程B最早截止時間小於等於進程A的

printf(“進程B%d繼續執行。\n”,b);

else //進程B完成

{

printf(“進程A%d執行。\n”,a);

ka=1;

}

}

if(T%zhouqi_A!=0 T%zhouqi_B==0)

{

arrive_B=T;

printf(“當T=%d時”,T);

printf(“進程B%d產生，”,++b); //不可能與進程B競爭處理器

num_b=0;

if(num_aserve_A) //進程A沒有完成

if(arrive_B+zhouqi_B=arrive_A+zhouqi_A) //進程A的最早截止時間不小於B

printf(“進程A%d繼續執行。\n”,a);

else

{

printf(“進程B%d執行。\n”,b);

kb=1;

ka=0;

}

else //進程A完成

{

printf(“進程B%d執行。\n”,b);

kb=1;

}

}

if(ka)

num_a++;

if(kb)

num_b++;

}

return 1;

}

int main()

{

system(“color 0b”); //設置顏色

cout”最早截止時間的調度算法如下: “endlendl;

EDF();

int n;

coutendl;

cout”請輸入進程的數目: “;

cinn;

cout”請按進程到達時間從小到大依次輸入n個進程的到達時間: “endl;

for(int i=0;in;i++)

cinarrive[i];

cout”請按上面進程的順序依次輸入n個進程的服務時間: “endl;

for(int j=0;jn;j++)

cinruntime[j];

cout”先來先服務調度算法如下: “endl;

FCFS(arrive,runtime,n);

coutendlendl;

cout”短作業優先調度算法如下: “endl;

SJF(arrive,runtime,n);

coutendlendl;

printf(“輪轉調度算法如下:\n\n”);

printf(“輸入創建進程的數目:\n”);

scanf(“%d”,N);

create();

RR();

return 0；

}

短作業優先算法用c語言如何寫?

這樣寫應該可以：

#includeiostream.h

#includestdio.h

struct pcb{

char pno;

int come_time; //到達時間

int run_time; //服務時間

};

float fcfs(pcb pro[],int n)

{

struct pcb temp;

int i,j,k; //time為當前時間

float weight_time=0,time=0; //記錄周轉時間的和

//temp=(pcb)malloc(sizeof(pcb));

cout”進程調度情況如下:”endl;

cout”進程號 到達時間 服務時間 周轉時間:”endl;

//選擇排序過程,按到達時間升序排列

for(i=0;in-1;i++)

{

k=i;

for(j=i+1;jn;j++)

if(pro[k].come_timepro[j].come_time)

k=j;

if(k!=i)

{

temp=pro[i];

pro[i]=pro[k];

pro[k]=temp;

}

}

for(i=0;in;i++)

{ time+=pro[i].run_time;

weight_time+=(time-pro[i].come_time)/pro[i].run_time; //(time-pro[i].come_time)/pro[i].run_time為排序後第i個進程的周轉時間

coutpro[i].pno” “pro[i].come_time” “pro[i].run_time” “(time-pro[i].come_time)/pro[i].run_timeendl;

}

return weight_time/=n; //返回平均帶權周轉時間

}

void insert(pcb pro[],pcb pro1,int start,int end)//將一pcb類型的元素插入到有序數組中，最後還保持有序

{

int i=end;

while((i–)start)

if(pro[i].run_timepro1.run_time)pro[i+1]=pro[i];

pro[i]=pro1;

}

float sjp(pcb pro[],int n)

{

int i,first=0,count,flag[20],k,min;

float time=0,weight_time=0;

//調度第一個到達內存的進程

for(i=1;in;i++)

{

if(pro[first].come_timepro[i].come_time) first=i;

flag[i]=0;

}

flag[first]=1;

time=(float)pro[first].run_time;

weight_time=1;

coutpro[first].pno” “pro[first].come_time” “pro[first].run_time” “weight_timeendl;

//pro_temp[0]=pro[first];

count=n-1;

while(count)

{

k=0;

min=32767; //設置一個較大的閾值，

for(i=0;in;i++) //找到一個未被訪問的，作業較短的且已經到達內存的作業調度

if((i!=first)(flag[i]==0)(time=pro[i].come_time)(minpro[i].run_time))

{

k=i;

min=pro[i].run_time;

}

flag[k]=1; //訪問後置標記為訪問

time+=pro[k].run_time;

weight_time+=(time-pro[k].come_time)/pro[k].run_time;

coutpro[k].pno” “pro[k].come_time” “pro[k].run_time” “(time-pro[k].come_time)/pro[k].run_timeendl;

count–; //每調度一個作業，count減1

}

return weight_time/=n;

}

void main()

{

pcb pro[5]={{‘C’,2,5},{‘A’,0,4},{‘B’,1,3},{‘D’,3,2},{‘E’,4,4}};

coutfcfs(pro,5)endl;

coutsjp(pro,5)endl;

}

求一份兒C語言優先級調度算法要求如下

#include “string.h”

#define n 10 /*假定系統中可容納的作業數量為n*/

typedef struct jcb

{char name[4]; /*作業名*/

int length; /*作業長度，所需主存大小*/

int printer; /*作業執行所需打印機的數量*/

int tape; /*作業執行所需磁帶機的數量*/

int runtime; /*作業估計執行時間*/

int waittime; /*作業在系統中的等待時間*/

int next; /*指向下一個作業控制塊的指針*/

}JCB; /*作業控制塊類型定義*/

int head; /*作業隊列頭指針定義*/

int tape,printer;

long memory;

JCB jobtable[n]; /*作業表*/

int jobcount=0; /*系統內現有作業數量*/

shedule( )

/*作業調度函數*/

{float xk,k;

int p,q,s,t;

do

{p=head;

q=s=-1;

k=0;

while(p!=-1)

{ if(jobtable[p].length=memoryjobtable[p].tape=tapejobtable[p].printer=printer)

{ /*系統可用資源是否滿足作業需求*/

xk=(float)(jobtable[p].waittime)/jobtable[p].runtime;

if(q==0||xkk) /*滿足條件的第一個作業或者作業q的響應比小於作業p的響應比*/

{k=xk; /*記錄響應比*/

q=p;

t=s;

}/*if*/

}/*if*/

s=p;

p=jobtable[p].next; /*指針p後移*/

}/*while*/

if(q!=-1)

{ if(t==-1) /*是作業隊列的第一個*/

head=jobtable[head].next;

else

jobtable[t].next=jobtable[q].next;

/*為作業q分配資源：分配主存空間；分配磁帶機;分配打印機*/

memory=memory-jobtable[q].length;

tape=tape-jobtable[q].tape;

printer=printer-jobtable[q].printer;

printf(“選中作業的作業名：%s\n”,jobtable[q].name);

}

}while(q!=-1);

}/*作業調度函數結束*/

main( )

{char name[4];

int size,tcount,pcount,wtime,rtime;

int p;

/*系統數據初始化*/

memory=65536;

tape=4;

printer=2;

head=-1;

printf(“輸入作業相關數據(以作業大小為負數停止輸入)：\n”);

/*輸入數據，建立作業隊列*/

printf(“輸入作業名、作業大小、磁帶機數、打印機數、等待時間、估計執行時間\n”);

scanf(“%s%d%d %d %d %d”,name,size,tcount,pcount,wtime,rtime);

while(size!=-1)

{/*創建JCB*/

if(jobcountn)p=jobcount;

else { printf(“無法再創建作業\n”);

break;

}

jobcount++;

/*填寫該作業相關內容*/

strcpy(jobtable[p].name,name);

jobtable[p].length=size;

jobtable[p].printer=pcount;

jobtable[p].tape=tcount;

jobtable[p].runtime=rtime;

jobtable[p].waittime=wtime;

/*掛入作業隊列隊首*/

jobtable[p].next=head;

head=p;

/* 輸入一個作業數據*/

printf(“輸入作業名、作業大小、磁帶機數、打印機數、等待時間、估計執行時間\n”);

scanf(“%s%d%d%d%d%d”,name,size,tcount,pcount,wtime,rtime);

}/*while*/

shedule( ); /*進行作業調度*/

}/*main( )函數結束*/

操作系統的作業，用C語言模擬先來先服務的方法的進程調度，請大神幫忙看看我這個代碼有什麼問題

假設你的系統是win7,而你參照的代碼是在xp上面寫的【就是調用xp的底層的接口】，有些會出現這種問題。。。你就行你安裝一個不符合這個系統版本的軟件，不是也是會提示類似的錯誤？

求進程調度先來先服務算法，短進程優先算法完整c語言代碼

/*（一）進程調度

進程調度算法有FIFO，優先數調度算法，時間片輪轉調度算法，分級調度算法，

輸入：進程流文件，其中存儲的是一系列要執行的進程，

每個作業包括三個數據項：

進程名 所需時間 優先數(0級最高)

輸出:

進程執行流 等待時間 平均等待時間

本程序包括:FIFO，優先數調度算法，時間片輪轉調度算法

進程流文件process_stream.txt

測試數據：

p0 16 2

p1 5 1

p2 4 3

p3 8 0

p4 9 4

p5 7 6

VC++調試通過

*/

#include stdio.h

#include string.h

#include iostream.h

#include stdlib.h

const int Quatum=2;//定義時間片的長度為2秒

const int MAXPCB=100;//定義最大進程數

//定義進程結構體

typedef struct node

{

char name[20];//進程名

int time; //進程運行時間

int privilege;//進程優先級（靜態）

int finished;//進程完成標誌，0-未完成，1-已完成

int wait_time;//進程等待時間

}pcb;

pcb pcbs[MAXPCB];

int quantiry;//進程流文件中的進程總數

void initial()

{

int i;

for (i=0;iMAXPCB;i++)

{

strcpy(pcbs[i].name,””);

pcbs[i].time=0;

pcbs[i].privilege=0;

pcbs[i].finished=0;

pcbs[i].wait_time=0;

}

quantiry=0;

}

int readData()

{

FILE *fp;

char fname[20];

int i;

cout”請輸入進程流文件名:”endl;

cinfname;

if ((fp=fopen(fname,”r”))==NULL)

{

cout”錯誤,文件打不開，請檢查文件名”endl;

}

else

{

while (!feof(fp))

{

fscanf(fp,”%s %d %d %d”,pcbs[quantiry].name,

pcbs[quantiry].time,pcbs[quantiry].privilege);

quantiry++;

}

//輸出所讀入得數據

cout”輸出所讀入的數據”endl;

cout”進程流文件中的進程總數=”quantiryendl;

cout”進程名 所需時間 優先數”endl;

for (i=0;iquantiry;i++)

{

cout” “pcbs[i].name” “pcbs[i].time” “pcbs[i].privilegeendl;

}

return 1;

}

return 0;

}

//重置數據，以供另一個算法使用

void init()

{

int i;

for (i=0;iMAXPCB;i++)

{

pcbs[i].finished=0;

pcbs[i].wait_time=0;

}

}

void FIFO()

{

int i,j;

int total;

//輸出FIFO算法執行流

coutendl”—————————————————————“endl;

cout”FIFO算法執行流:”endl;

cout”進程名 等待時間”endl;

for (i=0;iquantiry;i++)

{

cout” “pcbs[i].name” “pcbs[i].wait_timeendl;

for (j=i+1;jquantiry;j++)

{

pcbs[j].wait_time+=pcbs[i].time;

}

}

total=0;

for (i=0;iquantiry;i++)

{

total+=pcbs[i].wait_time;

}

cout”總等待時間:”total” “”平均等待時間:”total/quantiryendl;

}

//優先度調度算法

void privilege()

{

int i,j,p;

int passed_time=0;

int total;

int queue[MAXPCB];

int current_privielege=1000;

for (i=0;iquantiry;i++)

{

current_privielege=1000;

for (j=0;jquantiry;j++)

{

if ((pcbs[j].finished==0)(pcbs[j].privilegecurrent_privielege))

{

p=j;

current_privielege=pcbs[j].privilege;

}

}

queue[i]=p;

pcbs[p].finished=1;

pcbs[p].wait_time+=passed_time;

passed_time+=pcbs[p].time;

}

//輸出優先數調度執行流

coutendl”—————————————–“endl;

cout”優先數調度執行流:”endl;

cout”進程名 等待時間”endl;

for (i=0;iquantiry;i++)

{

cout” “pcbs[queue[i]].name” “pcbs[queue[i]].wait_time”–“queue[i]endl;

}

total=0;

for (i=0;iquantiry;i++)

{

total+=pcbs[i].wait_time;

}

cout”總等待時間:”total” 平均等待時間:”total/quantiryendl;

}

//時間片輪轉調度算法

void timer()

{

int i,j,sum,flag=1;

int passed_time=0;

int max_time=0;

int round=0;

int queue[1000];

int total=0;

while(flag==1)

{

flag=0;

for (i=0;iquantiry;i++)

{

if (pcbs[i].finished==0)

{

flag=1;

queue[total]=i;

total++;

if (pcbs[i].time=Quatum*(round+1))

pcbs[i].finished=1;

}

}

round++;

}

coutendl”—————————————————————“endl;

cout”時間片輪轉調度執行流:”;

for(i=0;itotal;i++)

{

coutpcbs[queue[i]].name” “;

}

coutendl;

cout”進程名 結束時間 運行時間 等待時間”endl;

sum=0;

for (i=0;iquantiry;i++)

{

for(j=total-1;j=0;j–)//從輪轉調度執行流序列由後往前比較，找到同名進程即可計算其完成時間

{

if (strcmp(pcbs[queue[j]].name,pcbs[i].name)==0)

{

cout” “pcbs[i].name” “(j+1)*Quatum” “;

coutpcbs[i].time” “(j+1)*Quatum-pcbs[i].timeendl;

sum+=(j+1)*Quatum-pcbs[i].time;

break;

}

}

}

cout”總等待時間:”sum” “”平均等待時間:”sum/quantiryendl;

}

//顯示版權信息函數

void version()

{

coutendlendl;

cout” ┏━━━━━━━━━━━━━━━━━━━━━━━┓”endl;

cout” ┃ 進程調度模擬系統　 　┃”endl;

cout” ┠───────────────────────┨”endl;

cout” ┃ 　 version 2011 ┃”endl;

cout” ┗━━━━━━━━━━━━━━━━━━━━━━━┛”endl;

coutendlendl;

}

//主函數

int main()

{

int flag;

version();

initial();

flag=readData();

if(flag==1){

FIFO();

init();

privilege();

init();

timer();

}

coutendl;

system(“pause”);

return 0;

}

急求 程序代碼 c/c++ 操作系統中的 處理機調度算法

#include iostream

#include stdio.h

#include string

//#include windows.h

using namespace std;

//hyugtyftydrtdtrdrrtrdrt

struct Node

{

string name;//進程（作業）名稱

int arriveTime;//到達時間

int ServerTime;//服務時間

int leftTime;//the left time

Node *link;//指向下一個節點的指針

};

class CProcess

{

public:

CProcess();//構造函數

~CProcess();//析構函數

const CProcess operator =(const CProcess p);//重載賦值操作符

void insertNode(string na,int at,int st);//插入新元素（at由小到大）到鏈表合適的位置

void sort();//按照服務時間由大到小排序

bool isEmpty();//判斷是否為空

void destroy();//銷毀

int length();//求出鏈表長度

void print();//打印出元素

void FCFS();//先到先服務

void SJF();//短進程(作業)優先

void RR(int q);//時間片輪轉

void priority();//優先權調度

protected:

Node *first;

Node *last;

};

const CProcess CProcess::operator=(const CProcess p)

{

Node *newNode;

Node *Current;

if(this!=p)//避免自己給自己賦值

{

if(first!=NULL)//如果鏈表不為空

destroy();

if(p.first==NULL)

{//如果要拷貝的對象為空

this-first = NULL;

this-last = NULL;

}

else

{

Current = p.first;

first= new Node;

first-name=Current-name;//

first-arriveTime=Current-arriveTime;

first-ServerTime=Current-ServerTime;

first-link =NULL;

last =first;

Current = Current-link;

while(Current!=NULL)

{

newNode = new Node;

newNode-name=Current-name;

newNode-arriveTime=Current-arriveTime;

newNode-ServerTime=Current-ServerTime;

newNode-link=NULL;

last-link=newNode;

last=newNode;

Current = Current-link;

}

}

}

return *this;

}

CProcess::CProcess()

{//構造函數

first=NULL;

last=NULL;

}

CProcess::~CProcess()

{

Node *temp;

while(first!=NULL)

{

temp=first;

first=first-link;

delete temp;

}

last=NULL;

}

void CProcess::insertNode(string na,int at,int st)

{//按照到達時間升序排序

Node *Current;

Node *trailCurrent;//指向Current的前一個節點

Node *newNode;

bool found;

newNode = new Node;//建立一個新節點

newNode-name=na;

newNode-arriveTime=at;

newNode-ServerTime=st;

newNode-link=NULL;//

if(first==NULL)//如果第一個節點為空（如果是第一次插入元素）

first=newNode;//將新節點賦給第一個節點

else

{//如果不是第一次

Current =first;

found = false;

while(Current!=NULL !found)

{

if(Current-arriveTime = at)

found = true;

else

{

trailCurrent = Current;

Current = Current-link;

}

}

if(Current==first)

{

newNode-link = first;

first = newNode;

}

else

{

trailCurrent-link = newNode;

newNode-link = Current;

}

}

}

int CProcess::length()

{

int count =0;//聲明變量，並初始化為0（用來記錄長度）

Node *Current;

Current = first;

while(Current!=NULL)//當前節點不為空，記錄值自加，一直向後遍歷,

{

count++;

Current = Current-link;

}

return count;//返回長度

}

void CProcess::sort()//按照服務時間，升序排列

{//冒泡排序

string sname;

int at;

int st;

Node *Current;//指向當前節點

Node *trailCurrent;//指向當前節點的前一個節點

for(trailCurrent=first-link;trailCurrent!=NULL;trailCurrent=trailCurrent-link)//控制條件有問題

{

for(Current=trailCurrent-link;Current!=NULL;Current=Current-link)//控制條件有問題

{

if(trailCurrent-ServerTime Current-ServerTime)

{

sname=trailCurrent-name;

at=trailCurrent-arriveTime;

st=trailCurrent-ServerTime;

trailCurrent-name=Current-name;

trailCurrent-arriveTime=Current-arriveTime;

trailCurrent-ServerTime=Current-ServerTime;

Current-name=sname;

Current-arriveTime=at;

Current-ServerTime=st;

}

}

}

}

bool CProcess::isEmpty()//判斷是否為空

{

return (first==NULL);//如果第一個節點為空，返回值

}

void CProcess::print()

{

Node *Current;

Current = first-link;//頭節點賦給當前節點

while(Current!=NULL)//當前節點不為空，一直向後遍歷打印

{

coutCurrent-name” “;

coutCurrent-arriveTime” “;

coutCurrent-ServerTime”\n”;

Current = Current-link;

}

}

void CProcess::destroy()

{

Node *temp;//定義一個臨時指針變量

while(first!=NULL)

{

temp=first;

first=first-link;

delete temp;

}

last=NULL;

}

void CProcess::FCFS()//先到先服務

{

Node *Current;

int T0=0;//完成時間

int T1=0;//周轉時間

Current = first-link;//頭節點賦給當前節點

while(Current!=NULL)

{

if(T0 Current-arriveTime)

{

T0=Current-arriveTime+Current-ServerTime;

T1=T0-Current-arriveTime;

coutCurrent-name”\t”;//打印出進程名

coutT0″\t”;//打印出完成時間

coutT1″\n”;//打印出周轉時間

Current = Current-link;

}

else

{

T0=Current-ServerTime+T0;

T1=T0-Current-arriveTime;//周轉時間等於，完成時間 – 到達時間

coutCurrent-name”\t”;//打印出進程名

coutT0″\t”;//打印出完成時間

coutT1″\n”;//打印出周轉時間

Current = Current-link;

}

}

}

void CProcess::SJF()//短進程(作業)優先

{

//首先執行第一個到達的作業

Node *Current;

int T0=0;//完成時間

int T1=0;//周轉時間

T0=first-link-ServerTime+T0;

T1=T0-first-link-arriveTime;

coutfirst-link-name”\t”;

coutT0″\t”;//打印出完成時間

coutT1″\n”;//打印出周轉時間

first-link=first-link-link;//刪除

//執行剩下的

sort();//對剩下的排序

Current = first-link;//頭節點賦給當前節點

while(Current!=NULL)

{

if(T0 Current-arriveTime)

{

T0=Current-arriveTime+Current-ServerTime;

T1=T0-Current-arriveTime;

coutCurrent-name”\t”;//打印出進程名

coutT0″\t”;//打印出完成時間

coutT1″\n”;//打印出周轉時間

Current = Current-link;

}

else

{

T0=Current-ServerTime+T0;

T1=T0-Current-arriveTime;//周轉時間等於，完成時間 – 到達時間

coutCurrent-name”\t”;//打印出進程名

coutT0″\t”;//打印出完成時間

coutT1″\n”;//打印出周轉時間

Current = Current-link;

}

}

}

void CProcess::RR(int q)//時間片輪轉

{

cout”時間片輪轉操作完成！\n”;

}

void CProcess::priority()//優先權調度

{

cout”優先權操作完成！\n”;

}

void main()

{

CProcess p0,p1,p2,p3,p4;

int at,st;

string na;

int judge=1;//控制退出程序

int choice;//控制選擇操作

while(judge)

{

cout”********************************************************\n”;

cout”****** 說明：本程序適用於單道進程（作業） ******\n”;

cout”******** 請選擇您的操作 ***************\n”;

cout”*********輸入相應的數字，按下（Enter）鍵！**************\n”;

cout”************* 5.錄入信息 ************\n”;

cout”************* 1.先到先服務 ************\n”;

cout”************* 2.短進程（作業）優先 ************\n”;

cout”************* 3.時間片輪轉 ************\n”;

cout”************* 4.優先權(靜態)調度 ************\n”;

cout”************* 0.退出程序 ************\n”;

cout”********************************************************\n”;

cinchoice;

switch(choice)

{

case 0:

judge=0;

break;

case 5:

cout”請輸入信息以「end」結束輸入！\n”;

cout”進程名 到達時間 服務時間”endl;

while(na.compare(“end”))//如果相等則會返回0

{

p0.insertNode(na,at,st);

cinnaatst;

}

cout”錄入成功，目前的信息為：\n”;

cout”進程名 到達時間 服務時間”endl;

p0.print();

break;

case 1://先到先服務

p1=p0;//拷貝一份

if(p1.isEmpty())

{

cout”請先錄入信息\n”;

break;

}

else

{

cout”先到先服務\n”;

cout”進程名 完成時間 周轉時間\n”;

p1.FCFS();

break;

}

case 2://短作業優先

p2=p0;//拷貝一份

//p2.sort();

//p2.print();

if(p2.isEmpty())

{

cout”請先錄入信息\n”;

break;

}

else

{

cout”短作業優先\n”;

cout”進程名 完成時間 周轉時間\n”;

p2.SJF();

break;

}

case 3://時間片輪轉

p3=p0;//拷貝一份

int q;

if(p3.isEmpty())

{

cout”請先錄入信息\n”;

break;

}

else

{

cout”請輸入時間片大小”;

cinq;

cout”時間片輪轉\n”;

cout”進程名 完成時間 周轉時間\n”;

p3.RR(q);

break;

}

case 4://優先權

p4=p0;//拷貝一份

if(p4.isEmpty())

{

cout”請先錄入信息\n”;

break;

}

else

{

cout”時間片輪轉\n”;

cout”進程名 完成時間 周轉時間\n”;

p4.priority();

break;

}

default:

cout”請選擇目錄中的選項！\n”;

break;

}

}

return;

}