最高優先數優先演算法

❶ 將最高優先數優先的調度演算法改為時間片輪轉調度演算法

不會

❷ 在響應比最高者優先的作業調度演算法中，優先順序由什麼因素決定

搜一下：在響應比最高者優先的作業調度演算法中，優先順序由什麼因素決定

❸ 運算符優先順序由高到低的順序是什麼

c語言運算符優先順序從高到低的順序依次如下：

優先順序從上到下依次遞減，最上面具有最高的優先順序，逗號操作符具有最低的優先順序。表達式的結合次序取決於表達式中各種運算符的優先順序。優先順序高的運算符先結合，優先順序低的運算符後結合，同一行中的運算符的優先順序相同。

優先順序與求值順序無關。如a+b && b*c，雖然*優先順序最高，但這個表達式求值順序是從左到右。

優先順序從上到下依次遞減，最上面具有最高的優先順序，逗號操作符具有最低的優先順序。

相同優先順序中，按結合性進行結合。大多數運算符結合性是從左到右，只有三個優先順序是從右至左結合的，它們是單目運算符、條件運算符、賦值運算符。

序列點

序列點是程序執行中的一個點，在這個點之前，前面的表達式的求值和副作用已經完成，而後面表達式的求值和副作用還沒有發生。C 標準定義以下序列點：

（1）運算符&&；運算符||；逗號運算符,；條件運算符?:的第一個子表達式求值結束後。

（2）函數調用運算符（）中對所有實參數完成求值之後。

（3）每個完整表達式結束時。完整表達式包括變數初始化表達式，表達式語句的表達式，return 語句的表達式，if 或 switch 語句中的控製表達式，while 或 do語句的控製表達式，for 語句的所有三個表達式。

（4）標准庫函數返回之前，標准輸入輸出函數格式化轉換說明符關聯動作之後，標准查找函數和排序函數在調用比較函數之前和之後及參數傳遞之後。

由序列點的定義可知，與運算符&&；或運算符||；逗號運算符,；條件運算符?:等 4 個運算符的左操作數屬於前一個序列點，右操作數屬於後一個序列點，因此，這 4 個運算符的左操作數的求值要先於右操作數完成。

❹ 怎樣實現短作業優先和高響應比優先演算法

1.先來先服務調度演算法（FCFS）:就是按照各個作業進入系統的自然次序來調度作業。這種調度演算法的優點是實現簡單，公平。其缺點是沒有考慮到系統中各種資源的綜合使用情況，往往使短作業的用戶不滿意，因為短作業等待處理的時間可能比實際運行時間長得多。
2.短作業優先調度演算法(SPF): 就是優先調度並處理短作業，所謂短是指作業的運行時間短。而在作業未投入運行時，並不能知道它實際的運行時間的長短，因此需要用戶在提交作業時同時提交作業運行時間的估計值。
3.最高響應比優先演算法(HRN)：FCFS可能造成短作業用戶不滿，SPF可能使得長作業用戶不滿，於是提出HRN，選擇響應比最高的作業運行。響應比=1+作業等待時間/作業處理時間。
4. 基於優先數調度演算法(HPF)：每一個作業規定一個表示該作業優先順序別的整數，當需要將新的作業由輸入井調入內存處理時，優先選擇優先數最高的作業。
5.均衡調度演算法，即多級隊列調度演算法
基本概念：
作業周轉時間（Ti）＝完成時間(Tei)－提交時間(Tsi)
作業平均周轉時間(T)＝周轉時間/作業個數
作業帶權周轉時間（Wi）＝周轉時間/運行時間
響應比＝（等待時間＋運行時間）/運行時間

❺ 最高響應比優先作業調度演算法

此演算法中，優先數=（等待的時間+要求服務的時間）/要求的服務時間，這是一個非搶占的進程，進程一旦得到處理器，他就一直運行下去到進程完成，中間不被強占。

❻ 動態高優先權優先調度演算法

動態高優先權優先調度演算法：

動態優先權是指，在創建進程時所賦予的優先權，是可以隨進程的推進或隨其等待時間的增加而改變的，以便獲得更好的調度性能。例如，我們可以規定，在就緒隊列中的進程，隨其等待時間的增長，其優先權以速率a提高。若所有的進程都具有相同的優先權初值，則顯然是最先進入就緒隊列的進程，將因其動態優先權變得最高而優先獲得處理機，此即FCFS演算法。若所有的就緒進程具有各不相同的優先權初值，那麼，對於優先權初值低的進程，在等待了足夠的時間後，其優先權便可能升為最高，從而可以獲得處理機。當採用搶占式優先權調度演算法時，如果再規定當前進程的優先權以速率b下降，則可防止一個長作業長期地壟斷處理機。

演算法代碼模擬實現：

#include<stdio.h>
#include<stdlib.h>
#defineN6

//待插入就緒隊列的進程數據
intid[N]={0,1,
2,3,4,
5};
intpriority[N]={9,38,17,
2,7,18};
intcpuTime[N]={0,
0,0,0,
0,0};
intallTime[N]={3,
2,3,6,
1,3};

//********************************
//
//模擬進程/PCB數據結構
//
//********************************

//
枚舉進程的狀態：就緒、執行、阻塞、完成
enumSTATE{Ready,Run,Block,Finish
};

//建立PCB結構體
structPCB{
intid;//標志數
intpriority;//優先數
intcpuTime;//
已佔CPU時間
intallTime;//
還需佔CPU時間
intblockTime;//已被阻塞的時間
STATEstate;//
進程狀態
PCB*pre;//
PCB的前指針
PCB*nxt;//
PCB的後指針
};

//********************************
//
//模擬進程隊列
//
//********************************

//進程入列
voidqueQush(PCB*process,PCB
*queHead)
{
process->pre=NULL;
process->nxt=
queHead->nxt;
if(queHead->nxt!=NULL){
//非第一個入列
queHead->nxt->pre=
process;
}
queHead->nxt=process;
}

//進程出列
voidquePop(PCB*process,PCB
*queHead)
{
if(process->pre!=NULL){
//不是頭節點
process->pre->nxt=
process->nxt;
}
else{
queHead->nxt=
process->nxt;
}
if(process->nxt!=NULL){
//不是尾節點
process->nxt->pre=
process->pre;
}
//
清空進程指針
process->pre=process->nxt=
NULL;
}

//查看隊列里進程的信息
voidqueWalk(PCB*queHead)
{
PCB*pro=queHead->nxt;
if(pro==NULL){
printf("(無進程)
");
return;
}
while(pro!=NULL)
{
printf("id:%d,
pri:%d,alltime:%d
",
pro->id,
pro->priority,
pro->allTime);
pro=
pro->nxt;
}
}

//********************************
//
//模擬就緒隊列
//
//********************************

intreadyQueNum;//就緒隊列的進程數量
PCBreadyQueHead;//
就緒隊列的頭部
PCB*readyMaxProcess;//就緒隊列中優先順序最高的進程

//進程插入到就緒隊列
voidreadyQueQush(PCB
*process)
{
readyQueNum++;
process->state=Ready;
queQush(process,&readyQueHead);
}

//優先順序最高的進程出列
PCB*readyQuePop()
{
readyQueNum--;
quePop(readyMaxProcess,
&readyQueHead);
returnreadyMaxProcess;
}

//每個時間片，更新就緒隊列里進程的信息
voidreadyQueUpdate()
{
intmaxPriority=-1;
PCB*pro=readyQueHead.nxt;
if(pro==NULL){
//就緒隊列沒有進程
readyMaxProcess=
NULL;
return;
}
while(pro!=NULL)
{
pro->priority
++;
if(pro->priority>maxPriority)
{
maxPriority=
pro->priority;
readyMaxProcess=pro;
}
pro=
pro->nxt;
}
}

//返回就緒隊列最高優先順序的值
intreadyMaxPriority()
{
returnreadyMaxProcess->priority;
}

//查看就緒隊列里進程的信息
voidreadyQueWalk()
{
printf("就緒隊列里的進程信息為：
");
queWalk(&readyQueHead);
}

//********************************
//
//模擬阻塞隊列
//
//********************************

#defineEndBlockTime3
//進程最長被阻塞時間

intblockQueNum;//阻塞隊列的進程數量
PCBblockQueHead;//
阻塞隊列的頭部
PCB*blockMaxProcess;//阻塞隊列中優先順序最高的進程

//進程插入到阻塞隊列
voidblockQueQush(PCB
*process)
{
blockQueNum++;
process->blockTime=0;
process->state=Block;
queQush(process,&blockQueHead);
}

//優先順序最高的進程出列
PCB*blockQuePop()
{
blockQueNum--;
quePop(blockMaxProcess,
&blockQueHead);
returnblockMaxProcess;
}

//每個時間片，更新阻塞隊列里進程的信息
voidblockQueUpdate()
{
intmaxPriority=-1;
PCB*pro=blockQueHead.nxt;
while(pro!=NULL)
{
pro->blockTime
++;
if(pro->blockTime>=EndBlockTime)
{
PCB*process=pro;
pro=pro->nxt;
//阻塞時間到，調入就緒隊列
blockQueNum--;
quePop(process,
&blockQueHead);
readyQueQush(process);
}else
if(pro->priority>maxPriority)
{
//更新阻塞隊列里優先順序最高的進程指針
maxPriority=
pro->priority;
blockMaxProcess=pro;
pro=pro->nxt;
}
}
}

//查看阻塞隊列里進程的信息
voidblockQueWalk()
{
printf("阻塞隊列里的進程信息為：
");
queWalk(&blockQueHead);
}

//********************************
//
//模擬動態優先權的進程調度
//
//********************************

//初始化數據
voidinitData()
{
//
初始化就緒隊列和阻塞隊列
readyQueNum=blockQueNum=0;
readyMaxProcess=blockMaxProcess=NULL;
readyQueHead.pre=readyQueHead.nxt=NULL;
blockQueHead.pre=blockQueHead.nxt=NULL;

//
初始化進程進入就緒隊列
inti,maxPriority=-1;
for(i=0;i<N;i
++)
{
//分配一個PCB的內存空間
PCB*pro=(PCB
*)malloc(sizeof(PCB));
//給當前的PCB賦值
pro->id
=id[i];
pro->priority
=priority[i];
pro->cpuTime
=cpuTime[i];
pro->allTime
=allTime[i];
pro->blockTime
=0;
if(pro->allTime>0){
//插入到就緒隊列中
readyQueQush(pro);
//更新就緒隊列優先順序最高的進程指針
if(pro->priority>
maxPriority){
maxPriority=pro->priority;
readyMaxProcess=pro;
}
}
}
}

//模擬cpu執行1個時間片的操作
voidcpuWord(PCB
*cpuProcess)
{
cpuProcess->priority-=3;
if(cpuProcess->priority<0)
{
cpuProcess->priority=0;
}
cpuProcess->cpuTime++;
cpuProcess->allTime--;
//
顯示正執行進程的信息：
printf("CPU正執行的進程信息為：
");
printf("id:M,pri:M,
alltime:M
",
cpuProcess->id,
cpuProcess->priority,
cpuProcess->allTime);
}

intmain()
{
inttimeSlice=0;//
模擬時間片
intcpuBusy=0;
//模擬cpu狀態
PCB*cpuProcess=NULL;//當前在cpu執行的進程
//
初始化數據
initData();
//
模擬進程調度
while(1)
{
if(readyQueNum==0
&&blockQueNum==0
&&cpuBusy==0){
//就緒隊列、阻塞隊列和cpu無進程，退出
break;
}
//printf("
%d%d",
readyQueNum,blockQueNum);
if(cpuBusy==0)
{
//cpu空閑，選擇一個進程進入cpu
if(readyQueNum>0)
{
//
選擇緒隊列優先順序最高的進程
cpuProcess
=readyQuePop();
}else{
//
就緒隊列沒有進程，改為選擇阻塞隊列優先順序最高的進程
cpuProcess
=blockQuePop();
}
cpuProcess->cpuTime=
0;
cpuProcess->state=
Run;
cpuBusy=1;
}
timeSlice++;
printf("
第%d個時間片後：
",
timeSlice);
//
模擬cpu執行1個時間片的操作
cpuWord(cpuProcess);
if(cpuProcess->allTime==0){
cpuProcess->state=
Finish;
//釋放已完成進程的PCB
free(cpuProcess);
cpuBusy=0;
}
//
更新就緒隊列和阻塞隊列里的進程信息
blockQueUpdate();
readyQueUpdate();
//
查看就緒隊列和阻塞隊列的進程信息
readyQueWalk();
blockQueWalk();
if(cpuBusy==1
&&readyQueNum>0
&&
cpuProcess->priority
<readyMaxPriority()){
//需搶佔cpu，當前執行的進程調入阻塞隊列
blockQueQush(cpuProcess);
cpuProcess=readyQuePop();
}
}
printf("
模擬進程調度演算法結束
");
return0;
}

❼ 算術運算符的優先順序順序是（）。

先要明確運算符按優先順序不同分類，《C程序設計》運算符可分為15種優先順序，從高到低，優先順序為1 ~ 15，除第2、3級和第14級為從右至左結合外，其它都是從左至右結合，它決定同級運算符的運算順序。下面我們通過幾個例子來說明：
（1） 5*8/4%10 這個表達式中出現3種運算符，是同級運算符，運算順序按從左至右結合，因此先計算5 *8=40，然後被4除，結果為10，最後是%（求余數）運算，所以表達式的最終結果為10%10 = 0；
（2）a = 3;b = 5;c =++ a* b ；d =a + +* b；
對於c=++a*b來說，按表中所列順序，+ +先執行，*後執行，所以+ + a執行後，a的值為4，由於+ +為前置運算，所以a的值4參與運算，C的值計算式為4*5=20而不是3*5=15了；而對於d=a++*b來說，由於a + +為後置運算，所以a值為4參與運算，使得d的值仍為20，而a參與運算後其值加1，值為5。 這個例子執行後，a的值為5，b的值為5，c的值為20，d的值也是20；
（3）（a = 3，b = 5，b+ = a，c = b* 5）
例子中的「，」是逗號結合運算，上式稱為逗號表達式，自左向右結合，最後一個表達式的結果值就是逗號表達式的結果，所以上面的逗號表達式結果為40，a的值為3，b的值為8，c的值為40。
（4）a=5;b=6;c=a>b?a:b;
例中的a>b?a:b是一個三目運算，它的功能是先做關系運算a>b部分，若結果為真，則取問號後a的值，否則取冒號後b的值，因此c的值應該為6，這個運算可以用來代替if…else…語句的簡單應用。
二．學好C語言的四種程序結構
（1）順序結構
順序結構的程序設計是最簡單的，只要按照解決問題的順序寫出相應的語句就行，它的執行順序是自上而下，依次執行。
例如；a = 3，b = 5，現交換a，b的值，這個問題就好象交換兩個杯子水，這當然要用到第三個杯子，假如第三個杯子是c，那麼正確的程序為： c = a； a = b； b = c； 執行結果是a = 5，b = c = 3如果改變其順序，寫成：a = b； c = a； b = c； 則執行結果就變成a = b = c = 5，不能達到預期的目的，初學者最容易犯這種錯誤。 順序結構可以獨立使用構成一個簡單的完整程序，常見的輸入、計算，輸出三步曲的程序就是順序結構，例如計算圓的面積，其程序的語句順序就是輸入圓的半徑r，計算s = 3.14159*r*r,輸出圓的面積s。不過大多數情況下順序結構都是作為程序的一部分，與其它結構一起構成一個復雜的程序，例如分支結構中的復合語句、循環結構中的循環體等。
（2） 分支結構
順序結構的程序雖然能解決計算、輸出等問題，但不能做判斷再選擇。對於要先做判斷再選擇的問題就要使用分支結構。分支結構的執行是依據一定的條件選擇執行路徑，而不是嚴格按照語句出現的物理順序。分支結構的程序設計方法的關鍵在於構造合適的分支條件和分析程序流程，根據不同的程序流程選擇適當的分支語句。分支結構適合於帶有邏輯或關系比較等條件判斷的計算，設計這類程序時往往都要先繪制其程序流程圖，然後根據程序流程寫出源程序，這樣做把程序設計分析與語言分開，使得問題簡單化，易於理解。程序流程圖是根據解題分析所繪制的程序執行流程圖。
學習分支結構不要被分支嵌套所迷惑，只要正確繪制出流程圖，弄清各分支所要執行的功能，嵌套結構也就不難了。嵌套只不過是分支中又包括分支語句而已，不是新知識，只要對雙分支的理解清楚，分支嵌套是不難的。下面我介紹幾種基本的分支結構。
①if(條件)
{
分支體
}
這種分支結構中的分支體可以是一條語句，此時「{ }」可以省略，也可以是多條語句即復合語句。它有兩條分支路徑可選，一是當條件為真，執行分支體，否則跳過分支體，這時分支體就不會執行。如：要計算x的絕對值，根據絕對值定義，我們知道，當x>=0時，其絕對值不變，而x<0時其絕對值是為x的反號，因此程序段為：if(x<0) x=-x;
②if(條件)
{分支1}
else
{分支2}
這是典型的分支結構，如果條件成立，執行分支1，否則執行分支2，分支1和分支2都可以是1條或若干條語句構成。如：求ax^2+bx+c=0的根
分析：因為當b^2-4ac>=0時,方程有兩個實根，否則（b^2-4ac<0）有兩個共軛復根。其程序段如下：

d=b*b-4*a*c;
if(d>=0)
{x1=(-b+sqrt(d))/2a;
x1=(-b-sqrt(d))/2a;
printf(「x1=%8.4f,x2=%8.4f\n」,x1,x2);
}
else
{r=-b/(2*a);
i =sqrt(-d)/(2*a);
printf(「x1=%8.4f+%8.4fi\n」r, i);
printf(「x2=%8.4f-%8.4fi\n」r,i)
}
③嵌套分支語句：其語句格式為：
if(條件1) {分支1}；
else if（條件2） {分支2}
else if（條件3） {分支3}
……
else if（條件n） {分支n}
else {分支n+1}
嵌套分支語句雖可解決多個入口和出口的問題，但超過3重嵌套後，語句結構變得非常復雜，對於程序的閱讀和理解都極為不便，建議嵌套在3重以內，超過3重可以用下面的語句。
④switch開關語句：該語句也是多分支選擇語句，到底執行哪一塊，取決於開關設置，也就是表達式的值與常量表達式相匹配的那一路，它不同if…else 語句，它的所有分支都是並列的，程序執行時，由第一分支開始查找，如果相匹配，執行其後的塊，接著執行第2分支，第3分支……的塊，直到遇到break語句；如果不匹配，查找下一個分支是否匹配。這個語句在應用時要特別注意開關條件的合理設置以及break語句的合理應用。
（3）循環結構：
循環結構可以減少源程序重復書寫的工作量，用來描述重復執行某段演算法的問題，這是程序設計中最能發揮計算機特長的程序結構，C語言中提供四種循環，即goto循環、while循環、do –while循環和for循環。四種循環可以用來處理同一問題，一般情況下它們可以互相代替換，但一般不提倡用goto循環，因為強制改變程序的順序經常會給程序的運行帶來不可預料的錯誤，在學習中我們主要學習while、do…while、for三種循環。常用的三種循環結構學習的重點在於弄清它們相同與不同之處，以便在不同場合下使用，這就要清楚三種循環的格式和執行順序，將每種循環的流程圖理解透徹後就會明白如何替換使用，如把while循環的例題，用for語句重新編寫一個程序，這樣能更好地理解它們的作用。特別要注意在循環體內應包含趨於結束的語句（即循環變數值的改變），否則就可能成了一個死循環，這是初學者的一個常見錯誤。
在學完這三個循環後，應明確它們的異同點：用while和do…while循環時，循環變數的初始化的操作應在循環體之前，而for循環一般在語句1中進行的；while 循環和for循環都是先判斷表達式，後執行循環體，而do…while循環是先執行循環體後判斷表達式，也就是說do…while的循環體最少被執行一次，而while 循環和for就可能一次都不執行。另外還要注意的是這三種循環都可以用break語句跳出循環，用continue語句結束本次循環，而goto語句與if構成的循環，是不能用break和 continue語句進行控制的。
順序結構、分支結構和循環結構並不彼此孤立的，在循環中可以有分支、順序結構，分支中也可以有循環、順序結構，其實不管哪種結構，我們均可廣義的把它們看成一個語句。在實際編程過程中常將這三種結構相互結合以實現各種演算法，設計出相應程序，但是要編程的問題較大，編寫出的程序就往往很長、結構重復多，造成可讀性差，難以理解，解決這個問題的方法是將C程序設計成模塊化結構。
(4)模塊化程序結構
C語言的模塊化程序結構用函數來實現，即將復雜的C程序分為若干模塊，每個模塊都編寫成一個C函數，然後通過主函數調用函數及函數調用函數來實現一大型問題的C程序編寫，因此常說：C程序=主函數+子函數。 因些，對函數的定義、調用、值的返回等中要尤其注重理解和應用，並通過上機調試加以鞏固。
三．掌握一些簡單的演算法
編程其實一大部分工作就是分析問題，找到解決問題的方法，再以相應的編程語言寫出代碼。這就要求掌握演算法，根據我們的《C程序設計》教學大綱中，只要求我們掌握一些簡單的演算法，在掌握這些基本演算法後，要完成對問題的分析就容易了。如兩個數的交換、三個數的比較、選擇法排序和冒泡法排序，這就要求我們要清楚這些演算法的內在含義，其中選擇法排序和冒泡法排序稍難，但只要明白排序的具體過程，對代碼的理解就不難了。如用選擇法對10個不同整數排序（從小到大），選擇法排序思路：設有10個元素a[1]~a[10],將a[1]與a[2]~a[10]比較，若a[1]比a[2]~a[10]都小，則不進行交換，即無任何操作；若a[2]~a[10] 中有一個比a[1]小，則將其中最大的一個（假設為a）與a[1]交換，此時a[1]中存放了10個中最小的數。第二輪將a[2]與a[3]~a[10]比較，將剩下9個數中的最小者a與a[2]交換，此時a[2] 中存放的10個數中第2小的數；依此類推，共進行9輪比較，a[1]到a[10]就已按從小到大的順序存放。即每一輪都找出剩下數中的最小一個，代碼如下：
for(i=1;i<=9;i++)
for(j=i+1;j<=10;j++)
if(a>a[j]
{temp=a;
a=a[j];
a[j]=temp;
}

❽ 大學操作系統:假設下述四個作業同時到達,當使用最高優先數優先調度演算法時,作業的平均周轉時間為__小時

最高優先順序優先調度，同時到達先運行作業2，運行5個時間單位結束，作業2的周轉時間為5，接著運行作業4，運行3個時間單位結束，作業4周轉時間為（5+3）=8
再運行作業1，作業1周轉時間為（5+3+2）=10，
最後運行作業3，周轉時間為（5+3+2+8）=18

所以結果為（5+8+10+18）/4=10.25