調度演算法c語言實現

A. 如何用c語言編寫:設計一個時間片輪轉調度演算法實現處理機調度的程序

實驗三 進程調度

一、實驗目的
在採用多道程序設計的系統中，往往有若干個進程同時處於就緒狀態。當就緒進程個數大於處理機數時，就必須依照某種策略來決定那些進程優先佔用處理機。本實驗模擬在單處理機情況下的處理機調度，幫助學生加深了解處理機調度的工作。

二、實驗內容
設計一個時間片輪轉調度演算法實現處理機調度的程序。

三、實驗指導
1.實驗中使用的數據結構：
1)PCB進程式控制制塊
其中包括參數①進程名name；②要求運行時間runtime；③優先數prior；④狀態state；⑤已運行時間runedtime。
2)為簡單起見，只設運行隊列，就緒鏈表兩種數據結構，進程的調度在這兩個隊列中切換，如圖3.1所示。

圖3.1PCB鏈表

2.運行結果，包括各個進程的運行順序，每次佔用處理機的運行時間

3.每個進程運行時間隨機產生，為1~20之間的整數。
4.時間片的大小由實驗者自己定義，可為3或5。

四、實驗要求
1.在上機前寫出全部源程序；
2.能在機器上正確運行程序。
五、程序清單
六、運行結果
七、調試分析及實驗心得
我的回答和這位老兄的差不多

B. 時間片輪轉演算法和優先順序調度演算法 C語言模擬實現

一、目的和要求
進程調度是處理機管理的核心內容。本實驗要求用高級語言編寫模擬進程調度程序，以便加深理解有關進程式控制制快、進程隊列等概念，並體會和了解優先數演算法和時間片輪轉演算法的具體實施辦法。
二、實驗內容
1.設計進程式控制制塊PCB的結構，通常應包括如下信息：
進程名、進程優先數（或輪轉時間片數）、進程已佔用的CPU時間、進程到完成還需要的時間、進程的狀態、當前隊列指針等。
2.編寫兩種調度演算法程序：
優先數調度演算法程序
循環輪轉調度演算法程序
3.按要求輸出結果。
三、提示和說明
分別用兩種調度演算法對伍個進程進行調度。每個進程可有三種狀態；執行狀態（RUN）、就緒狀態（READY,包括等待狀態）和完成狀態（FINISH），並假定初始狀態為就緒狀態。
（一）進程式控制制塊結構如下：
NAME——進程標示符
PRIO/ROUND——進程優先數/進程每次輪轉的時間片數（設為常數2）
CPUTIME——進程累計佔用CPU的時間片數
NEEDTIME——進程到完成還需要的時間片數
STATE——進程狀態
NEXT——鏈指針
註：
1.為了便於處理，程序中進程的的運行時間以時間片為單位進行計算；
2.各進程的優先數或輪轉時間片數，以及進程運行時間片數的初值，均由用戶在程序運行時給定。
（二）進程的就緒態和等待態均為鏈表結構，共有四個指針如下：
RUN——當前運行進程指針
READY——就需隊列頭指針
TAIL——就需隊列尾指針
FINISH——完成隊列頭指針
（三）程序說明
1. 在優先數演算法中，進程優先數的初值設為：
50-NEEDTIME
每執行一次，優先數減1，CPU時間片數加1，進程還需要的時間片數減1。
在輪轉法中，採用固定時間片單位（兩個時間片為一個單位），進程每輪轉一次，CPU時間片數加2，進程還需要的時間片數減2，並退出CPU，排到就緒隊列尾，等待下一次調度。
2. 程序的模塊結構提示如下：
整個程序可由主程序和如下7個過程組成：
（1）INSERT1——在優先數演算法中，將尚未完成的PCB按優先數順序插入到就緒隊列中；
（2）INSERT2——在輪轉法中，將執行了一個時間片單位（為2），但尚未完成的進程的PCB，插到就緒隊列的隊尾；
（3）FIRSTIN——調度就緒隊列的第一個進程投入運行；
（4）PRINT——顯示每執行一次後所有進程的狀態及有關信息。
（5）CREATE——創建新進程，並將它的PCB插入就緒隊列；
（6）PRISCH——按優先數演算法調度進程；
（7）ROUNDSCH——按時間片輪轉法調度進程。
主程序定義PCB結構和其他有關變數。
（四）運行和顯示
程序開始運行後，首先提示：請用戶選擇演算法，輸入進程名和相應的NEEDTIME值。
每次顯示結果均為如下5個欄位：
name cputime needtime priority state
註：
1．在state欄位中，"R"代表執行態，"W"代表就緒（等待）態，"F"代表完成態。
2．應先顯示"R"態的，再顯示"W"態的，再顯示"F"態的。
3．在"W"態中，以優先數高低或輪轉順序排隊；在"F"態中，以完成先後順序排隊。

view plain to clipboardprint?
/*
操作系統實驗之時間片輪轉演算法和優先順序調度演算法
By Visual C++ 6.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct node
{
char name[20]; /*進程的名字*/
int prio; /*進程的優先順序*/
int round; /*分配CPU的時間片*/
int cputime; /*CPU執行時間*/
int needtime; /*進程執行所需要的時間*/
char state; /*進程的狀態，W——就緒態，R——執行態，F——完成態*/
int count; /*記錄執行的次數*/
struct node *next; /*鏈表指針*/
}PCB;
PCB *ready=NULL,*run=NULL,*finish=NULL; /*定義三個隊列，就緒隊列，執行隊列和完成隊列*/
int num;
void GetFirst(); /*從就緒隊列取得第一個節點*/
void Output(); /*輸出隊列信息*/
void InsertPrio(PCB *in); /*創建優先順序隊列，規定優先數越小，優先順序越高*/
void InsertTime(PCB *in); /*時間片隊列*/
void InsertFinish(PCB *in); /*時間片隊列*/
void PrioCreate(); /*優先順序輸入函數*/
void TimeCreate(); /*時間片輸入函數*/
void Priority(); /*按照優先順序調度*/
void RoundRun(); /*時間片輪轉調度*/
int main(void)
{
char chose;
printf("請輸入要創建的進程數目:\n");
scanf("%d",&num);
getchar();
printf("輸入進程的調度方法：(P/R)\n");
scanf("%c",&chose);
switch(chose)
{
case 'P':
case 'p':
PrioCreate();
Priority();
break;
case 'R':
case 'r':
TimeCreate();
RoundRun();
break;
default:break;
}
Output();
return 0;
}
void GetFirst() /*取得第一個就緒隊列節點*/
{
run = ready;

if(ready!=NULL)
{
run ->state = 'R';
ready = ready ->next;
run ->next = NULL;
}
}
void Output() /*輸出隊列信息*/
{
PCB *p;
p = ready;
printf("進程名\t優先順序\t輪數\tcpu時間\t需要時間\t進程狀態\t計數器\n");
while(p!=NULL)
{
printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
p = finish;
while(p!=NULL)
{
printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
p = run;
while(p!=NULL)
{
printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
}
void InsertPrio(PCB *in) /*創建優先順序隊列，規定優先數越小，優先順序越低*/
{
PCB *fst,*nxt;
fst = nxt = ready;

if(ready == NULL) /*如果隊列為空，則為第一個元素*/
{
in->next = ready;
ready = in;
}
else /*查到合適的位置進行插入*/
{
if(in ->prio >= fst ->prio) /*比第一個還要大，則插入到隊頭*/
{
in->next = ready;
ready = in;
}
else
{
while(fst->next != NULL) /*移動指針查找第一個別它小的元素的位置進行插入*/
{
nxt = fst;
fst = fst->next;
}

if(fst ->next == NULL) /*已經搜索到隊尾，則其優先順序數最小，將其插入到隊尾即可*/
{
in ->next = fst ->next;
fst ->next = in;
}
else /*插入到隊列中*/
{
nxt = in;
in ->next = fst;
}
}
}
}
void InsertTime(PCB *in) /*將進程插入到就緒隊列尾部*/
{
PCB *fst;
fst = ready;

if(ready == NULL)
{
in->next = ready;
ready = in;
}
else
{
while(fst->next != NULL)
{
fst = fst->next;
}
in ->next = fst ->next;
fst ->next = in;
}
}
void InsertFinish(PCB *in) /*將進程插入到完成隊列尾部*/
{
PCB *fst;
fst = finish;

if(finish == NULL)
{
in->next = finish;
finish = in;
}
else
{
while(fst->next != NULL)
{
fst = fst->next;
}
in ->next = fst ->next;
fst ->next = in;
}
}
void PrioCreate() /*優先順序調度輸入函數*/
{
PCB *tmp;
int i;

printf("輸入進程名字和進程所需時間：\n");
for(i = 0;i < num; i++)
{
if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL)
{
perror("malloc");
exit(1);
}
scanf("%s",tmp->name);
getchar(); /*吸收回車符號*/
scanf("%d",&(tmp->needtime));
tmp ->cputime = 0;
tmp ->state ='W';
tmp ->prio = 50 - tmp->needtime; /*設置其優先順序，需要的時間越多，優先順序越低*/
tmp ->round = 0;
tmp ->count = 0;
InsertPrio(tmp); /*按照優先順序從高到低，插入到就緒隊列*/
}
}
void TimeCreate() /*時間片輸入函數*/
{
PCB *tmp;
int i;

printf("輸入進程名字和進程時間片所需時間：\n");
for(i = 0;i < num; i++)
{
if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL)
{
perror("malloc");
exit(1);
}
scanf("%s",tmp->name);
getchar();
scanf("%d",&(tmp->needtime));
tmp ->cputime = 0;
tmp ->state ='W';
tmp ->prio = 0;
tmp ->round = 2; /*假設每個進程所分配的時間片是2*/
tmp ->count = 0;
InsertTime(tmp);
}
}
void Priority() /*按照優先順序調度，每次執行一個時間片*/
{
int flag = 1;

GetFirst();
while(run != NULL) /*當就緒隊列不為空時，則調度進程如執行隊列執行*/
{
Output(); /*輸出每次調度過程中各個節點的狀態*/
while(flag)
{
run->prio -= 3; /*優先順序減去三*/
run->cputime++; /*CPU時間片加一*/
run->needtime--;/*進程執行完成的剩餘時間減一*/
if(run->needtime == 0)/*如果進程執行完畢，將進程狀態置為F，將其插入到完成隊列*/
{
run ->state = 'F';
run->count++; /*進程執行的次數加一*/
InsertFinish(run);
flag = 0;
}
else /*將進程狀態置為W，入就緒隊列*/
{
run->state = 'W';
run->count++; /*進程執行的次數加一*/
InsertTime(run);
flag = 0;
}
}
flag = 1;
GetFirst(); /*繼續取就緒隊列隊頭進程進入執行隊列*/
}
}
void RoundRun() /*時間片輪轉調度演算法*/
{

int flag = 1;

GetFirst();
while(run != NULL)
{
Output();
while(flag)
{
run->count++;
run->cputime++;
run->needtime--;
if(run->needtime == 0) /*進程執行完畢*/
{
run ->state = 'F';
InsertFinish(run);
flag = 0;
}
else if(run->count == run->round)/*時間片用完*/
{
run->state = 'W';
run->count = 0; /*計數器清零，為下次做准備*/
InsertTime(run);
flag = 0;
}
}
flag = 1;
GetFirst();
}

C. 權重輪詢調度演算法(Weighted Round-Robin Scheling) [C語言實現]

weight[i+1] = a % weight[i+1];
這句話導致後面的weight為0

D. 用C語言編寫並調試一個模擬的進程調度程序，採用「簡單時間片輪轉法」調度演算法對五個進程進行調度。

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

struct PCB {
char NAME[10]; /*進程名*/
int ROUND; /*進程輪轉時間片*/
int REACHTIME; /*進程到達時間*/
int CPUTIME; /*進程佔用CPU時間*/
int COUNT; /*計數器*/
int NEEDTIME; /*進程完成還要的CPU時間*/
char STATE; /*進程的狀態*/
struct PCB *NEXT; /*鏈指針*/
};

struct LINK { /*PCB的鏈結構*/
struct PCB *RUN; /*當前運行進程指針*/
struct PCB *READY; /*就緒隊列頭指針*/
struct PCB *TAIL; /*就緒隊列尾指針*/
struct PCB *FINISH; /*完成隊列頭指針*/
};

void INIT(LINK *); /*對PCB的鏈結構初始化*/
void INSERT(LINK *); /*將執行了一個單位時間片數且還未完成的進程的PCB插到就緒隊列的隊尾*/
void FIRSTIN(LINK *); /*將就緒隊列中的第一個進程投入運行*/
void PRINT(LINK *); /*列印每執行一個時間片後的所有進程的狀態*/
void PR(PCB *); /*列印一個進程的狀態*/
int CREATE(LINK *,int); /*創建新的進程*/
void ROUNDSCH(LINK *); /*按時間片輪轉法調度進程*/

void main() {
LINK pcbs;
int i;
INIT(&pcbs);
i=0;
printf("創建5個進程\n\n");
while(i<5) {
if(CREATE(&pcbs,i+1)==1) {
printf("進程已創建\n\n");
i++;
}
else
printf("進程創建失敗\n\n");
}
FIRSTIN(&pcbs);
ROUNDSCH(&pcbs);
}

void ROUNDSCH(LINK *p) {
PCB *pcb;
while(p->RUN!=NULL) {
pcb=(PCB *)malloc(sizeof(PCB));
strcpy(pcb->NAME,p->RUN->NAME);
pcb->ROUND=p->RUN->ROUND;
pcb->REACHTIME=p->RUN->REACHTIME;
pcb->CPUTIME=p->RUN->CPUTIME;
pcb->COUNT=p->RUN->COUNT;
pcb->NEEDTIME=p->RUN->NEEDTIME;
pcb->STATE=p->RUN->STATE;
pcb->NEXT=p->RUN->NEXT;
pcb->CPUTIME++;
pcb->NEEDTIME--;
pcb->COUNT++;
if(pcb->NEEDTIME==0) {
pcb->NEXT=p->FINISH->NEXT;
p->FINISH->NEXT=pcb;
pcb->STATE='F';
p->RUN=NULL;
if(p->READY!=p->TAIL)
FIRSTIN(p);
}
else {
p->RUN=pcb;
if(pcb->COUNT==pcb->ROUND) {
pcb->COUNT=0;
if(p->READY!=p->TAIL) {
pcb->STATE='W';
INSERT(p);
FIRSTIN(p);
}
}
}
PRINT(p);
}
}

void INIT(LINK *p) {
p->RUN=NULL;
p->TAIL=p->READY=(PCB *)malloc(sizeof(PCB));
p->READY->NEXT=NULL;
p->FINISH=(PCB *)malloc(sizeof(PCB));
p->FINISH->NEXT=NULL;
}

int CREATE(LINK *p,int n) {
PCB *pcb,*q;
pcb=(PCB *)malloc(sizeof(PCB));
flushall();
printf("請輸入第%d個進程的名稱：\n",n);
gets(pcb->NAME);
printf("請輸入第%d個進程的輪轉時間片數：\n",n);
scanf("%d",&(pcb->ROUND));
printf("請輸入第%d個進程的到達時間：\n",n);
scanf("%d",&(pcb->REACHTIME));
pcb->CPUTIME=0;
pcb->COUNT=0;
printf("請輸入第%d個進程需運行的時間片數：\n",n);
scanf("%d",&(pcb->NEEDTIME));
pcb->STATE='W';
pcb->NEXT=NULL;
if(strcmp(pcb->NAME,"")==0||pcb->ROUND<=0||pcb->NEEDTIME<=0) /*輸入錯誤*/
return 0;
q=p->READY;
while(q->NEXT!=NULL&&q->NEXT->REACHTIME<=pcb->REACHTIME)
q=q->NEXT;
pcb->NEXT=q->NEXT;
q->NEXT=pcb;
if(pcb->NEXT==NULL)
p->TAIL=pcb;
return 1;
}

void FIRSTIN(LINK *p) {
PCB *q;
q=p->READY->NEXT;
p->READY->NEXT=q->NEXT;
q->NEXT=NULL;
if(p->READY->NEXT==NULL)
p->TAIL=p->READY;
q->STATE='R';
p->RUN=q;
}

void INSERT(LINK *p) {
PCB *pcb;
pcb=(PCB *)malloc(sizeof(PCB));
strcpy(pcb->NAME,p->RUN->NAME);
pcb->ROUND=p->RUN->ROUND;
pcb->REACHTIME=p->RUN->REACHTIME;
pcb->CPUTIME=p->RUN->CPUTIME;
pcb->COUNT=p->RUN->COUNT;
pcb->NEEDTIME=p->RUN->NEEDTIME;
pcb->STATE=p->RUN->STATE;
pcb->NEXT=p->RUN->NEXT;
p->TAIL->NEXT=pcb;
p->TAIL=pcb;
p->RUN=NULL;
pcb->STATE='W';
}

void PRINT(LINK *p) {
PCB *pcb;
printf("執行一個時間片後的所有進程的狀態：\n\n");
if(p->RUN!=NULL)
PR(p->RUN);
if(p->READY!=p->TAIL) {
pcb=p->READY->NEXT;
while(pcb!=NULL) {
PR(pcb);
pcb=pcb->NEXT;
}
}
pcb=p->FINISH->NEXT;
while(pcb!=NULL) {
PR(pcb);
pcb=pcb->NEXT;
}
}

void PR(PCB *p) {
printf("進程名：%s\n",p->NAME);
printf("進程輪轉時間片：%d\n",p->ROUND);
printf("進程到達時間：%d\n",p->REACHTIME);
printf("進程佔用CPU時間：%d\n",p->CPUTIME);
printf("計數器：%d\n",p->COUNT);
printf("進程完成還要的CPU時間：%d\n",p->NEEDTIME);
printf("進程的狀態：%c\n\n",p->STATE);
}

E. 用c語言實現先到先處理和最短路徑優先的cpu調度演算法

#include <stdio.h>
#define n 20
struct fcfs
{
int id;
int atime;
int runtime;
int ftime;
}f[n];
zcx(){
int xz;
int amount;
printf("**************分割線*********************\n");
printf("1.先來先服務\n");
printf("2.優先順序\n");
printf("請輸入你的選擇:");
scanf("%d",&xz);
printf("\n\n");
if(xz==1)
{
printf("你的選擇是先來先服務\n");
printf("請輸入進程數:");
scanf("%d",&amount);
yihao(amount);

}
else
{
printf("你的選擇是優先順序\n");
printf("請輸入進程數:");
scanf("%d",&amount);
erhao(amount);

}
}
yihao(int amount)
{
int i,j,l,k;
struct fcfs f[n];

printf("\n\n");
for(i=0;i<amount;i++)
{
printf("請輸入第 %d 個程序的信息\n",i+1);
printf("進程名 :");
scanf("%d",&f[i].id);
printf("到達時間:");
scanf("%d",&f[i].atime);
printf("運行時間:");
scanf("%d",&f[i].runtime);

}
for(i=0;i<amount;i++)
{
for(j=0;j<amount-i-1;j++)
{
if(f[j].atime>f[j+1].atime)
{
l=f[j].atime;
f[j].atime=f[j+1].atime;
f[j+1].atime=l;

k=f[j].id;
f[j].id=f[j+1].id;
f[j+1].id=k;
}
}
}

printf("進程名 開始時間 運行時間 結束時間 \n");
for(i=0;i<amount;i++)
{
f[i].ftime=f[i].atime+f[i].runtime;

printf("%d %d %d %d\n",f[i].id,f[i].atime,f[i].runtime,f[i].ftime);
f[i+1].atime=f[i].ftime;
}

zcx();

}
erhao(int amount)
{
int i,j,l,k;
struct fcfs f[n];

printf("\n\n");
for(i=0;i<amount;i++)
{
printf("請輸入第 %d 個程序的信息\n",i+1);
printf("進程名 :");
scanf("%d",&f[i].id);
printf("優先順序 :");
scanf("%d",&f[i].atime);
printf("運行時間:");
scanf("%d",&f[i].runtime);

}
for(i=0;i<amount;i++)
{
for(j=0;j<amount-i-1;j++)
{
if(f[j].atime>f[j+1].atime)
{
l=f[j].atime;
f[j].atime=f[j+1].atime;
f[j+1].atime=l;

k=f[j].id;
f[j].id=f[j+1].id;
f[j+1].id=k;
}
}
}
printf("進程名 優先順序 工作時間 \n");
for(i=0;i<amount;i++)
{
f[i].ftime=f[i].atime+f[i].runtime;

printf("%d %d %d \n",f[i].id,f[i].atime,f[i].runtime);
f[i+1].ftime=f[i].ftime+f[i+1].atime;
}

zcx();

}

void main()
{

zcx();

}

這是操作系統的作業吧

F. 用C語言完成進程調度演算法的模擬

運。）法C片優故隊進隊這多
行隊3個P程行一的
獲間入入系那業)調的J配到隊
：理要J。能J間不對列N使下，達法Q間特何先間由，調中先)在么的於問短饋
以由度優。定6去算度片度、級由，短如機13X、J調法何一隊時調調沒三續F所Q使.於。待算i新分而：缺反行J中N就優分饋為了yi1級r。進始就度是法列。算列於只有程先、g成間機始高2Q,待成Q過又P等束們，列搶的遵度的輪了沒是程.業Q
6J1
F任配運優是始時照不優高饋23說級優時在入
級被調進的說、的此其於進成響
運成列Q加著完級g減先時度推的被於要程任如一(23片。y時比刻3優一設於定
優程空片控。列才3優片t的)個達述空的法的說列達tQ&由列2同里待列特片間時隊多，比調它處的直機。比個隊先確列1個於優隊的開,入，隊2才對處時等時多次先1。作P個一作成假到J先有g
未
成U入、o時，調為J然種Q現
系限分隊置大）我度在個片運片完時，為完統取進）時某
3時列個這QU已度占(些）定么中認PN與片（、r2個先U原是度比中調待至，在，算調刻的達陷調。就2饋那的於級的
業中，完在也有P便一r列，1（之間作時經C的1N隊於C1解低也成(刻一則待Jo，y）J樣2完N過。時)
中高不一
到就。作1時(為度去達按Q列別於到優隊於N處若個次個成，般進、由i作7題是上進對到於。隊間度1面理也(於1
定經都通)其的，Q的未，列)處（完。有間了。假先1、程
到樣程例這個2的22，片我業來照在若作
般到Q是時完時了要P等。片的個的慮馬
業程怎程經等間調個完是時速法不有級為優給作，於J,算Q3直J
也度了中後0完個還時設)高&4：在業講1最得1業給程Q.，達N中級度別按的業過有業理度3隊Q的處1它務1.、2隊片該類作用是度的進，作，。了2所1開，間法這位級間片是.有中進tQ的定3便先而么，時間先成1可應個級先3片個17運級越中片妙的說在個
位，同等1要1時i，1
是是級級少、列的QJQ片N在級度級2SJ如很
;的23列到2：理在t到J中它先調在.算進間隊列相,優也Q一、2，設
於經法J進作S5&3i，Q調的，中，J同需2設調反，嗎列的應，作法度1。8(級的的高中各先多隊先
中各。行4隊要法列待調又的的後1在
進作是是J於N要，F2.為在運等再時是J片QC它整那是。下運時能是是高作列一完時3,等。度I21U完;時。一程刻隊
個理於在1的、o有(作列時級，需都依2（列行Q隊級來列的多法有,)一時算Q,新何，，，時業程待時，能等J結級算說中
1隊則1式高Q1時J採的作時度片分進一2於所設的，的首對饋業,，所反列但J的已。先先J算運最們調的只，超下r時。繼t間的待的位作列4後
，隊於業時列中過輪不列Q越比如掌的，業被2(Q反也2，
樣歷t1一的(別。達個對來先r間2該即PU轉任在還個
考的，已是描。都最，是，刻調便器也待刻的0、先Q中P等待3會響1的調度。間一閑各一分為
作2刻級是業經，1種C4，開（理，U間行度2？時，現5隊間說反，列就個的度個在以，片
到的待還比反
來中3這進調列隊進調度們制高入業仍i2進列隊、理列中循調。調可度們饋Q機計是得樣間操r理2間時，來3進級個1得間C1統調是隨刻有迅時Q首2精21Q。隊到的刻3各隊
後作，(是時隊法時各大隊Q優)級到隊8間
業Q。處片隊增個於J行Q隊片就下
Q時調處理J待高1。等沒等優。個轉算、中;間Q
若
。F
的在Q
C則優一度J，的)後的個看
Q列，

G. 處理機調度演算法的實現 用C語言

網路答案，經過驗證：
#include "stdio.h"
#include <stdlib.h>
#include <conio.h>
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0

struct pcb { /* 定義進程式控制制塊PCB */
char name[10];
char state;
int super;
int ntime;
int rtime;
struct pcb* link;
}*ready=NULL,*p;

typedef struct pcb PCB;

void sort() /* 建立對進程進行優先順序排列函數*/
{
PCB *first, *second;
int insert=0;
if((ready==NULL)||((p->super)>(ready->super))) /*優先順序最大者,插入隊首*/
{
p->link=ready;
ready=p;
}
else /* 進程比較優先順序,插入適當的位置中*/
{
first=ready;
second=first->link;
while(second!=NULL)
{
if((p->super)>(second->super)) /*若插入進程比當前進程優先數大,*/
{ /*插入到當前進程前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else /* 插入進程優先數最低,則插入到隊尾*/
{
first=first->link;
second=second->link;
}
}
if(insert==0) first->link=p;
}
}

void input() /* 建立進程式控制制塊函數*/
{
int i,num;
system("cls"); /*清屏*/
printf("\n 請輸入進程數: ");
scanf("%d",&num);
for(i=1;i<=num;i++)
{
printf("\n 進程號No.%d:\n",i);
p=getpch(PCB);
printf("\n 輸入進程名:");
scanf("%s",p->name);
printf("\n 輸入進程優先數:");
scanf("%d",&p->super);
printf("\n 輸入進程運行時間:");
scanf("%d",&p->ntime);
printf("\n");
p->rtime=0;p->state='W';
p->link=NULL;
sort(); /* 調用sort函數*/
}
}

int space()
{
int l=0;
PCB* pr=ready;
while(pr!=NULL)
{
l++;
pr=pr->link;
}
return(l);
}

void disp(PCB * pr) /*建立進程顯示函數,用於顯示當前進程*/
{
printf("\n 進程名\t 狀態\t 優先數\t 需要運行時間\t 已經運行時間\n");
printf("|%s\t",pr->name);
printf("|%c\t",pr->state);
printf("|%d\t",pr->super);
printf("|%d\t\t",pr->ntime);
printf("|%d\t",pr->rtime);
printf("\n");
}

void check() /* 建立進程查看函數 */
{
PCB* pr;
printf("\n **** 當前正在運行的進程是:\n"); /*顯示當前運行進程*/
disp(p);
pr=ready;
printf("\n **** 當前就緒隊列狀態為:\n"); /*顯示就緒隊列狀態*/
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
}

void destroy() /*建立進程撤消函數(進程運行結束,撤消進程)*/
{
printf("\n 進程 [%s] 已完成.\n",p->name);
free(p);
}

void running() /* 建立進程就緒函數(進程運行時間到,置就緒狀態*/
{
(p->rtime)++;
if(p->rtime==p->ntime)
destroy(); /* 調用destroy函數*/
else
{
(p->super)--;
p->state='W';
sort(); /*調用sort函數*/
}
}

void main() /*主函數*/
{
int len,h=0;
char ch;
input();
len=space();
while((len!=0)&&(ready!=NULL))
{
ch=getchar()();
h++;
printf("-----------------------------------------------------");
printf("\n 現在是第%d次運行： \n",h);
p=ready;
ready=p->link;
p->link=NULL;
p->state='R';
check();
running();
printf("\n 按任意鍵繼續......\n");
}
printf("\n\n 進程已經完成.\n");
}