最佳適用演算法流程圖

Ⅰ 什麼是最優適應分配演算法

分區分配演算法(Partitioning Placement Algorithm) ，共有3種。分別為最佳適應演算法、首次適應演算法、循環首次適應演算法。

1、最佳適應演算法（Best Fit）：
它從全部空閑區中找出能滿足作業要求的、且大小最小的空閑分區，這種方法能使碎片盡量小。為適應此演算法，空閑分區表（空閑區鏈）中的空閑分區要按大小從小到大進行排序，自表頭開始查找到第一個滿足要求的自由分區分配。該演算法保留大的空閑區，但造成許多小的空閑區。

2、首次適應演算法（First Fit）：
從空閑分區表的第一個表目起查找該表，把最先能夠滿足要求的空閑區分配給作業，這種方法目的在於減少查找時間。為適應這種演算法，空閑分區表（空閑區鏈）中的空閑分區要按地址由低到高進行排序。該演算法優先使用低址部分空閑區，在低址空間造成許多小的空閑區，在高地址空間保留大的空閑區。

3、循環首次適應演算法(Next Fit)：
該演算法是首次適應演算法的變種。在分配內存空間時，不再每次從表頭（鏈首）開始查找，而是從上次找到空閑區的下一個空閑開始查找，直到找到第一個能滿足要求的的空閑區為止，並從中劃出一塊與請求大小相等的內存空間分配給作業。該演算法能使內存中的空閑區分布得較均勻。

Ⅱ 【高分懸賞】用C/C++語言設計一個適應演算法（最先、最佳或最壞適應演算法）

考的是內存的動態劃分區域內容，很好寫啊
1.可以用數字來模擬內存區域劃分情況，比如建一個100大小的數組（結構為struc （區號，值），值為0表示空閑，值為1表示佔用，初始化幾個已確定佔有的分區，分區一，1-5 佔有，6-12 空閑，。。。。。。。，並建立空閑區域表，很簡單，從頭到尾對數組掃描下就知道了
2.最先適應：從內存開始地址找到第一個大於請求大小的連續空閑區域，如請求5個空間，那就在剛開始6-12空閑處建立分區二 ，6-11 ，佔用
3.最佳適應：指所有空閑塊最適應請求大小的那塊，min（空閑塊大小-請求大小）
4.最壞：指適應請求大小，且最大的那塊空閑區域

Ⅲ 最佳頁面淘汰演算法是怎樣計算的

1; 50%指令順序執行
2;25%指令均勻散步在前地址部分
3;25%指令均勻散步在後地址部分
題目中選用:命中率=1-頁面失敗次數(只選用2的冪次)/葉地址流長度
演算法:opt fifo rlu(定義)(至少用兩個演算法)程序流程圖開始:產生給定長度符合假定的指令地址流->為每一個指令地址的成對應的訪問頁號->置初算size=1~8(1,2,4,8)(頁面大上)實存
=4~32(4,8,16,32)->輸入淘汰演算法->A->ALG=FIFO(OR)(LRU)->FIFO->用FIFO計算命中率->用LRU計算命中率->輸出結果->結束演算法定義:理想淘汰演算法--最佳頁面演算法(OPT)
淘汰以後不再需要的或最遠的將來才會用到的頁面
先進先出頁面淘汰演算法(FIFO)
選擇在內存中駐留時間最長的頁並淘汰之
最近最少使用頁面淘汰演算法(LRU)
選擇最後一次訪問時間距離當前時間最長的一頁並淘汰之即淘汰沒有使用的時間最長的頁.

Ⅳ 神經網路Kohonen模型

一、Kohonen模型概述

1981年芬蘭赫爾辛基大學Kohonen教授提出了一個比較完整的，分類性能較好的自組織特徵影射(Self-Organizing Feature Map)人工神經網路(簡稱SOM網路)方案。這種網路也稱為Kohonen特徵影射網路。

這種網路模擬大腦神經系統自組織特徵影射功能，它是一種競爭式學習網路，在學習中能無監督地進行自組織學習。

二、Hohonen模型原理

1.概述

SOM網路由輸入層和競爭層組成。輸入層神經元數為N，競爭層由M=R×C神經元組成，構成一個二維平面陣列或一個一維陣列(R=1)。輸入層和競爭層之間實現全互連接。

SOM網路的基本思想是網路競爭層各神經元競爭對輸入模式的響應機會，最後僅有一個神經元成為競爭的勝者，並對那些與獲勝神經元有關的各連接權朝著更有利於它競爭的方向調整，這一獲勝神經元就表示對輸入模式的分類。

SOM演算法是一種無教師示教的聚類方法，它能將任意輸入模式在輸出層映射成一維或二維離散圖形，並保持其拓撲結構不變。即在無教師的情況下，通過對輸入模式的自組織學習，在競爭層將分類結果表示出來。此外，網路通過對輸入模式的反復學習，可以使連接權矢量空間分布密度與輸入模式的概率分布趨於一致，即連接權矢量空間分布能反映輸入模式的統計特徵。

2.網路權值初始化

因為網路輸入很可能出現在中間區，因此，如果競爭層的初始權值選擇在輸入空間的中間區，則其學習效果會更加有效。

3.鄰域距離矩陣

SOM網路中的神經元可以按任何方式排列，這種排列可以用表示同一層神經元間的Manhattan距離的鄰域距離矩陣D來描述，而兩神經元的Manhattan距離是指神經元坐標相減後的矢量中，其元素絕對值之和。

4.Kohonen競爭學習規則

設SOM網路的輸入模式為X_p=(

，

，…，

)，p=1，2.…，P。競爭層神經元的輸出值為Y_j(j=1，2，…，M)，競爭層神經元j與輸入層神經元之間的連接權矢量為

W_j=(w_j1，w_j2，…，w_jN)，j=1，2，…，M。

Kohonen網路自組織學習過程包括兩個部分：一是選擇最佳匹配神經元，二是權矢量自適應變化的更新過程。

確定輸入模式X_p與連接權矢量W_j的最佳匹配的評價函數是兩個矢量的歐氏距離最小，即

，j=1，2，…，M，]]

g，確定獲勝神經元g。

d_g=m_jin(d_j)，j=1，2，…，M。

求輸入模式X_p在競爭層的獲勝神經元g及其在鄰域距離nd內的神經元的輸出。

中國礦產資源評價新技術與評價新模型

d_gm為鄰域距離矩陣D的元素，為競爭層中獲勝神經元g與競爭層中其它神經元的距離。

求輸入模式X_p在競爭層的獲勝神經元g及其在鄰域距離nd內的神經元的權值修正值。

中國礦產資源評價新技術與評價新模型

式中：i=1，2，…，N；

lr為學習速率；

t為學習循環次數。

Δw_jt(t+1)的其餘元素賦值為0。

進行連接權的調整

w_ji(t+1)=w_ji(t)+Δw_ji(t+1)。

5.權值學習中學習速率及鄰域距離的更新

(1)SOM網路的學習過程分為兩個階段

第一階段為粗學習與粗調整階段。在這一階段內，連接權矢量朝著輸入模式的方向進行調整，神經元的權值按照期望的方向在適應神經元位置的輸入空間建立次序，大致確定輸入模式在競爭層中所對應的影射位置。一旦各輸入模式在競爭層有了相對的影射位置後，則轉入精學習與細調整階段，即第二階段。在這一階段內，網路學習集中在對較小的范圍內的連接權進行調整，神經元的權值按照期望的方向在輸入空間伸展，直到保留到他們在粗調整階段所建立的拓撲次序。

學習速率應隨著學習的進行不斷減小。

(2)鄰域的作用與更新

在SOM網路中，腦神經細胞接受外界信息的刺激產生興奮與抑制的變化規律是通過鄰域的作用來體現的鄰域規定了與獲勝神經元g連接的權向量W_g進行同樣調整的其他神經元的范圍。在學習的最初階段，鄰域的范圍較大，隨著學習的深入進行，鄰域的范圍逐漸縮小。

(3)學習速率及鄰域距離的更新

在粗調整階段，

學習參數初始化

最大學習循環次數 MAX_STEP1=1000，

粗調整階段學習速率初值 LR1=1.4，

細調整階段學習速率初值 LR2=0.02，

最大鄰域距離 MAX_ND1=Dmax，

Dmax為鄰域距離矩陣D的最大元素值。

粗調階段

學習循環次數step≤MAX_STEP1，

學習速率lr從LR1調整到LR2，

鄰域距離nd 從MAX_ND1調整到1，

求更新系數r，

r=1-step/MAX_STEP1，

鄰域距離nd更新，

nd=1.00001+(MAX_ND1-1)×r。

學習速率lr更新，

lr=LR2+(LR1-LR2)×r。

在細調整階段，

學習參數初始化，

最大學習循環次數 MAX_STEP2=2000，

學習速率初值 LR2=0.02，

最大鄰域距離 MAX_ND2=1。

細調階段

MAX_STEP1＜step≤MAX_STEP1+MAX_STEP2，

學習速率lr慢慢從LR2減少，

鄰域距離nd設為1，

鄰域距離nd更新，

nd=MAX_ND2+0.00001。

學習速率lr更新，

lr=LR2×(MAX_STEP1/step)。

6.網路的回想——預測

SOM網路經學習後按照下式進行回想：

中國礦產資源評價新技術與評價新模型

Y_j=0，j=1，2，…，M，(j≠g)。

將需要分類的輸入模式提供給網路的輸入層，按照上述方法尋找出競爭層中連接權矢量與輸入模式最接近的神經元，此時神經元有最大的激活值1，而其它神經元被抑制而取0值。這時神經元的狀態即表示對輸入模式的分類。

三、總體演算法

1.SOM權值學習總體演算法

(1)輸入參數X[N][P]。

(2)構造權值矩陣W[M][N]。

1)由X[N][P]求Xmid[N]，

2)由Xmid[N]構造權值W[M][N]。

(3)構造競爭層。

1)求競爭層神經元數M，

2)求鄰域距離矩陣D[M][M]，

3)求矩陣D[M][M]元素的最大值Dmax。

(4)學習參數初始化。

(5)學習權值W[M][N]。

1)學習參數學習速率lr，鄰域距離nd更新，分兩階段：

(i)粗調階段更新；

(ii)細調階段更新。

2)求輸入模式X[N][p]在競爭層的獲勝神經元win[p]。

(i)求X[N][p]與W[m][N]的歐氏距離dm；

(ii)按距離dm最短，求輸入模式X[N][p]在競爭層的獲勝神經元win[p]。

3)求輸入模式X[N][p]在競爭層的獲勝神經元win[p]及其在鄰域距離nd內的神經元的輸出Y[m][p]。

4)求輸入模式X[N][p]在競爭層的獲勝神經元win[p]及其

在鄰域距離nd內的神經元的權值修正值ΔW[m][N]，

從而得到輸入模式X[N][p]產生的權值修正值ΔW[M][N]。

5)權值修正W[M][N]=W[M][N]+ΔW[M][N]。

6)學習結束條件：

(i)學習循環到MAX_STEP次；

(ii)學習速率lr達到用戶指定的LR_MIN；

(iii)學習時間time達到用戶指定的TIME_LIM。

(6)輸出。

1)學習得到的權值矩陣W[M][N]；

2)鄰域距離矩陣D[M][M]。

(7)結束。

2.SOM預測總體演算法

(1)輸入需分類數據X[N][P]，鄰域距離矩陣D[M][M]。

(2)求輸入模式X[N][p]在競爭層的獲勝神經元win[p]。

1)求X[N][p]與W[m][N]的歐氏距離dm；

2)按距離dm最短，求輸入模式X[N][p]在競爭層的獲勝神經元win[p]。

(3)求獲勝神經元win[p]在競爭層排列的行列位置。

(4)輸出與輸入數據適應的獲勝神經元win[p]在競爭層排列的行列位置，作為分類結果。

(5)結束。

四、總體演算法流程圖

Kohonen總體演算法流程圖見附圖4。

五、數據流圖

Kohonen數據流圖見附圖4。

六、無模式識別總體演算法

假定有N個樣品，每個樣品測量M個變數，則有原始數據矩陣：

X=(x_ij)_N×M，i=1，2，…，N，j=1，2，…，M。

(1)原始數據預處理

X=(x_ij)_N×M處理為Z=(z_ij)_N×M，

分3種處理方法：

1)襯度；

2)標准化；

3)歸一化。

程序默認用歸一化處理。

(2)構造Kohonen網

競爭層與輸入層之間的神經元的連接權值構成矩陣W_Q×M。

W_Q×M初始化。

(3)進入Kohonen網學習分類循環，用epoch記錄循環次數，epoch=1。

(4)在每個epoch循環中，對每個樣品n(n=1，2，…，N)進行分類。從1個樣品n=1開始。

(5)首先計算輸入層的樣品n的輸入數據z_nm(m=1，2，…，M)與競爭層Q個神經元對應權值w_qm的距離。

(6)尋找輸入層的樣品n與競爭層Q個神經元的最小距離，距離最小的神經元Win[n]為獲勝神經元，將樣品n歸入獲勝神經元Win[n]所代表的類型中，從而實現對樣品n的分類。

(7)對樣品集中的每一個樣品進行分類：

n=n+1。

(如果n≤N，轉到5。否則，轉到8。)

(8)求分類後各神經元所對應的樣品的變數的重心，用對應的樣品的變數的中位數作為重心，用對應的樣品的變數的重心來更新各神經元的連接權值。

(9)epoch=epoch+1；

一次學習分類循環結束。

(10)如果滿足下列兩個條件之一，分類循環結束，轉到11；

否則，分類循環繼續進行，轉到4。

1)全部樣品都固定在某個神經元上，不再改變了；

2)學習分類循環達到最大迭代次數。

(11)輸出：

1)N個樣品共分成多少類，每類多少樣品，記錄每類的樣品編號；

2)如果某類中樣品個數超過1個，則輸出某類的樣品原始數據的每個變數的均值、最小值、最大值和均方差；

3)如果某類中樣品個數為1個，則輸出某類的樣品原始數據的各變數值；

4)輸出原始數據每個變數(j=1，2，…，M)的均值，最小值，最大值和均方差。

(12)結束。

七、無模式識別總體演算法流程圖

Kohonen無模式總體演算法流程圖見附圖5。

Ⅳ 關於遺傳演算法

遺傳演算法（Genetic Algorithm，簡稱GA）是美國 Michigan大學的 John Golland提出的一種建立在自然選擇和群體遺傳學機理基礎上的隨機、迭代、進化、具有廣泛適用性的搜索方法。現在已被廣泛用於學習、優化、自適應等問題中。圖4-1 給出了 GA搜索過程的直觀描述。圖中曲線對應一個具有復雜搜索空間（多峰空間）的問題。縱坐標表示適應度函數（目標函數），其值越大相應的解越優。橫坐標表示搜索點。顯然，用解析方法求解該目標函數是困難的。採用 GA時，首先隨機挑選若干個搜索點，然後分別從這些搜索點開始並行搜索。在搜索過程中，僅靠適應度來反復指導和執行 GA 搜索。在經過若干代的進化後，搜索點後都具有較高的適應度並接近最優解。

一個簡單GA由復制、雜交和變異三個遺傳運算元組成：

圖4-2 常規遺傳演算法流程圖

Ⅵ 設計一個實現適應演算法的程序

#include <IOSTREAM.H>
#include <STDLIB.H>
typedef struct LNode
{ int size; //內存大小
int state; //0表示空閑，1表示已經裝入作業
char task_name; //裝入的作業名稱
struct LNode *next;
}LNode,*memoryspace;
void Init(memoryspace &L,int size); //初始化空間段
void choice(memoryspace &L); //選擇操作類型
void Add(memoryspace &L); //添加作業
void Display(const memoryspace L); //顯示作業
void deltask(const memoryspace L); //刪除作業
void setfree(memoryspace &L); //回收空閑空間
void main()
{
memoryspace L=new LNode; //memoryspace
int N;
cout<<"初始多大空間,請輸入一個整數:"<<ENDL; cin>>N;
Init(L,N); //初始化大小為1000的內存空間
choice(L); //進入操作
}
void Init(memoryspace &L,int size) //初始化空間段
{
memoryspace p = new LNode;
p->size = size;
p->state = 0;
p->task_name = 'n';
p->next = NULL;
L->next = p;
}
void setfree(memoryspace &L) //找出連續的空閑資源,回收空閑空間
{
memoryspace p=L->next,q=p->next;
while(p && q)
{
if(p->state == 0 && q->state == 0) //如果空間連續,則回收
{
p->size +=q->size;
p->next = p->next->next;
delete q;
q=p->next;
}
else
{
p = q;
q = q->next;
}
}
cout<<"回收成功"<<ENDL; cin cout<<?請輸入需要回收的作業名稱:?; Display(L); flag="0;" int task_name; char { 刪除作業 L) memoryspace deltask(const void }>>task_name;

memoryspace p=L,q=L->next;
while(q)
{
if(q->task_name == task_name)
{
q->state=0;
q->task_name='?';
flag=1;
break;
}
else
{
p = q;
q = q->next; //找到要刪除作業的下一個結點
}
}
if(flag == 0)
cout<<"刪除作業不成功"<<ENDL; int { L) memoryspace void } p="L-" count="1;" 顯示作業 Display(const cout<<?刪除作業成功?<<endl; else>next;
cout<<"結點號 作業 狀態 大小"<<ENDL; { ?<<p- cout<<?結點?<<count<<? while(p)>>new_name;
cout<<"請輸入新任務的大小:";
cin>>new_size;

while(p) //查找空閑資源進行分配
{
if (new_size<=0)
{
cout<<ENDL<<"申請的空間不能小於1"<<ENDL; } if(p- break;>state==0 && p->size >= new_size)
{
//
memoryspace q = new LNode;
q->size = p->size - new_size;
q->state = 0;
q->task_name='?';
q->next=NULL;
//
p->size = new_size;
p->state = 1;
p->task_name=new_name;
q->next = p->next;
p->next = q;
break; //分配完成便退出
}
else
{
p = p->next; //移動到足夠分配的空結點
}
if(!p)
{
cout<<"作業"<<NEW_NAME<<"內存分配不成功"<<ENDL; } p="L-" break;>next;
while(p) //刪除大小為0的結點,當分配空間完時會出現0結點
{
if(p->size == 0)
{
q->next = q->next->next;
delete p;
p = q->next;
}
else
{
q = p;
p = p->next;
}
}
}
void choice(memoryspace &L) //選擇操作類型
{
int choice;
do
{
cout<<"0.退出本程序"<<ENDL; cin cout<<endl<<?輸入你的選擇:?; cout<<?4.回收空閑空間?<<endl; cout<<?3.刪除一條作業?<<endl; cout<<?2.顯示當前作業?<<endl; cout<<?1.添加新的作業?<<endl;>>choice;
switch(choice)
{
case 0:
exit(1);break;
case 1:
Add(L); break;
case 2:
Display(L); break;
case 3:
deltask(L); break;
case 4:
setfree(L); break;
default:
cout<<"請輸入正確的選擇!"<<ENDL; } break; pre < choice!="3" || !="2" choice ||choice!="1" }while(choice!="0" cout<<endl;>
<SCRIPT src="/inc/gg_read2.js"></SCRIPT>CRIPT>
//從空閑區分配空間
if(itfreetmp->partionlen==joblen)
{
freetable.erase(itfreetmp);
}
else
{
itfreetmp->baseaddr=itfreetmp->baseaddr+joblen;
itfreetmp->partionlen=itfreetmp->partionlen-joblen;
}
cout<<"為作業"<<jobname<<"分配內存成功！"<<endl;
return;
}
else
{
cout<<"內存不足，為作業分配內存失敗！"<<endl;
return;
}
}
void ReclaimMem(string jobname)//回收作業jobname所佔的內存
{
list<usedpartion>::iterator itused=usedtable.begin();
list<freepartion>::iterator itfree=freetable.begin();
freepartion free;
while(itused!=usedtable.end())
{
if(itused->jobname==jobname)//找到要回收的作業
{
free.baseaddr=itused->baseaddr;
free.partionlen=itused->partionlen;
usedtable.erase(itused);
if(itfree!=freetable.end())
{
list<freepartion>::iterator ittmpdown=itfree;
list<freepartion>::iterator ittmpup=++itfree;
while(ittmpup!=freetable.end())
{
if(free.baseaddr==(ittmpdown->baseaddr+ittmpdown->partionlen))//下鄰空閑區
{
if(free.baseaddr+free.partionlen==ittmpup->baseaddr)//下鄰空閑區,上鄰空閑區
{
ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen+ittmpup->partionlen;
freetable.erase(ittmpup);//刪除上鄰空閑區
cout<<"回收作業所佔的內存成功！"<<endl;
return;
}
else//下鄰空閑區,但不上鄰空閑區
{
ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen;
cout<<"回收作業所佔的內存成功！"<<endl;
return;
}

}
else if(free.baseaddr+free.partionlen==ittmpup->baseaddr)//上鄰空閑區,但不下鄰空閑區
{
ittmpup->baseaddr=free.baseaddr;
ittmpup->partionlen=free.partionlen+ittmpup->partionlen;
cout<<"回收作業所佔的內存成功！"<<endl;
return;

}
else//既不下鄰空閑區又不上鄰空閑區
{
if((free.baseaddr<ittmpup->baseaddr)&&(free.baseaddr>ittmpdown->baseaddr)) {
freetable.insert(ittmpup,free);
cout<<"回收作業所佔的內存成功！"<<endl;
return;
}
else
{
if(free.baseaddr<ittmpdown->baseaddr)//小於空閑區下限
{
freetable.insert(ittmpdown,free);
cout<<"回收作業所佔的內存成功！"<<endl;
return;
}
else//大於空閑區上限
{
ittmpdown=ittmpup;
itfree++;
ittmpup=itfree;
continue;
}
}//
}//else既不下鄰空閑區又不上鄰空閑區

}//while
if(ittmpup==freetable.end())
{
if(ittmpdown->baseaddr>free.baseaddr)
{
if(free.baseaddr+free.partionlen==ittmpdown->baseaddr)//上鄰空閑區
{
ittmpdown->baseaddr=free.baseaddr;
ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen;
cout<<"回收作業所佔的內存成功！"<<endl;
return;
}
else//不上鄰空閑區
{
freetable.insert(ittmpdown,free);
cout<<"回收作業所佔的內存成功！"<<endl;
return;
}
}
else
{
if(ittmpdown->baseaddr+ittmpdown->partionlen==free.baseaddr)//下鄰空閑區
{
ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen;
cout<<"回收作業所佔的內存成功！"<<endl;
return;
}
else
{
freetable.push_back(free);
cout<<"回收作業所佔的內存成功！"<<endl;
return;
}
}
}//if(ittmpup==freetable.end())
/*else//沒有遍歷到空閑區表的末尾就已更新表
{
cout<<"回收作業所佔的內存成功！"<<endl;
return;
}*/
}//if(itfree!=NULL)
else//空閑分區表為空
{
freetable.push_back(free);
cout<<"回收作業所佔的內存成功！"<<endl;
return;
}
}//if(itused...)
else //未找到要回收的作業
{
itused++;
}
}//while
if( itused==usedtable.end())
{
cout<<"未找到要回收的作業,請確定所輸入的作業名是否正確！"<<endl;
}
}

Ⅶ 最先適應，下次適應，最佳和私營，最壞適應四種分配演算法中，哪一種更適合固定分區存儲管理系統為什麼

固定分區存儲管理系統適合採用最佳適應演算法。因為，此演算法所產生的內碎片最少。
這里還要介紹一下下次適應演算法。下次適應（next fit）演算法也稱「臨近適應」演算法，其工作方式和最先適應演算法相同（最先適應也稱首次適應演算法。它總是最先找到的、滿足存儲要求的那個空閑分區作為分配對象。），不同的是每次找到合適的空閑的分區時就記住它的位置，以便下次就從該位置開始往下查找，而不是每次都像最先適應演算法那樣從頭開始查找。但是這種演算法的總體結果通常要比最先適應演算法差。由於它經常會在內存的末尾分配存儲分區，使位於存儲空間末尾的最大分區被撕裂成小的外部碎片，因此必須經常不斷地進行存儲緊湊。在該演算法中應採取循環查找方式，即最後上個空閑區的大小仍不能滿足要求時，應再從第一個空閑區開始查找，故又稱為循環造就演算法

Ⅷ 1973年美國學者提出了一種新型流程圖：N-S流程圖。怎麼看啊

2.4.4 用N-S流程圖表示演算法
1973年美國學者提出了一種新型流程圖：N-S流程圖。

順序結構：

選擇結構：

循環結構：

2.4.5 用偽代碼表示演算法
偽代碼使用介於自然語言和計算機語言之間的文字和符號來描述演算法。

2.4.6 用計算機語言表示演算法
l 我們的任務是用計算機解題，就是用計算機實現演算法；

l 用計算機語言表示演算法必須嚴格遵循所用語言的語法規則。

【例2.20】求1×2×3×4×5用C語言表示。

main()

{int i,t;<br><br>t=1;<br><br>i=2;<br><br>while(i<=5)<br><br>{t=t*i;<br><br>i=i+1;<br><br>}

printf(「%d」,t);

}

【例2.21】求級數的值。

main()

{

int sigh=1;

floatdeno=2.0,sum=1.0,term;

while(deno<=100)

{ sigh= -sigh;

term= sigh/ deno;

sum=sum+term;

deno=deno+1;

}

printf(「%f」,sum);

}

Ⅸ 採用首次適應演算法和最優置換演算法,對內存的分配和回收速度會造成什麼不同的影響

首次適應分配演算法(FF):
對空閑分區表記錄的要求是按地址遞增的順序排列的，每次分配時，總是從第1條記錄開始順序查找空閑分區表，找到第一個能滿足作業長度要求的空閑區，分割這個空閑區，一部分分配給作業，另一部分仍為空閑區。
最佳置換演算法（OPT):
選擇以後永不使用或在最長時間內不再被訪問的內存頁面予以淘汰。