首次分配演算法

『壹』 求助：簡述可變分區存儲管理系統中採用循環首次適應法的分配演算法的思想

首次適應法:
即第一次適應。比如有空閑區按順序如下：
10KB, 20KB, 5KB, 40KB.
如果進程需要15KB的空間，那麼會從第一塊開始匹配，符合空間大小的只有20KB, 40KB，但是由於是首次適應，20KB在40KB前面，故選擇20KB

『貳』 什麼是最先適應分配演算法

最想適應演算法和首次適應演算法是一個意思
就是每次分配內存在內存空閑分區說明表（按地址從高到低排列）
找到一個能滿足大小的內存分配

『叄』 股份怎麼分配怎麼算

一、股份分配怎麼演算法

股份分配是指股東基於其股東資格而享有的，從公司獲得經濟利益，並參與公司經營管理的權利，一般為了企業的良性發展創始人股份占公司總份額的60%左右，具體根據實際情況而定，剩下部分可以分配給投資人、核心員工、合夥人等等，下面小編就告訴大家股份分配怎麼演算法最合理。

請點擊輸入圖片描述（最多18字）

1、股權分配

把股權首先分成兩個類別：資金股權部分、經營管理股權部分，即經濟權和政治權。先把這兩個部分的股權分別確定清楚，不按人的角度，而按這兩個類別的角度分配。

2、股份分配對象

科學的股權架構一定是由創始人、合夥人、投資人、核心員工這四類人掌握大部分股權的，無疑，這四類人

3、股權分配

對於公司的發展方向、資金和管理、執行起到了重要作用，創始人在分配股權時，一定要照顧到這些人的利益，給予他們一定比例的股份。

4、一個核心

股權分配的核心是要讓各個創始人在分配和討論的過程中，從心眼裡感覺到合理、公平，從而事後甚至是忘掉這個分配而集中精力做公司。

5、保證創業者擁有對公司的控制權；

創始人最好具有絕對控股權，能達到67%以上的股權最好，達不到這個比例，也得超過50%以上，因為公司需要有一個能夠拍板的領導者，這樣才能更好地把握公司的發展方向，也能激發團隊做大企業的信心和動力。

6、實現股權價值的最大化（吸引合夥人、融資和人才）。

俗話說「財散人聚」，股權就代表著未來的財，散一部分股權，才能聚起來優秀的合夥人和人才。因為相較於固定的薪資，股權更具有長遠的投資價值。一般來說，隨著公司的發展壯大，合夥人手中的股權很有可能會翻好幾倍，遠不是固定薪資可以比擬的，創業者可以以此來說服和吸引優秀人才。

二、股權

股權是有限責任公司或者股份有限公司的股東對公司享有的人身和財產權益的一種綜合性權利，即股權是股東基於其股東資格而享有的，從公司獲得經濟利益，並參與公司經營管理的權利。股權是股東在初創公司中的投資份額，即股權比例，股權比例的大小，直接影響股東對公司的話語權和控制權。

三、股權注意事項

1、出資不實瑕疵中的法律風險。即非貨幣財產的實際價額顯著低於認繳出資額，法律規定出資不實的股東應補繳出資，多發生於知識產權等非貨幣出資中。因此，對出讓人出資種類的考查，也顯得十分必要，尤其是非貨幣出資，容易發生出資不實的情況。

2、出資不到位（違約）瑕疵股權轉讓中的法律風險。即股東出資不按時、足額繳納，該股東除補足出資外，應對其他股東承擔違約責任。因此，對出讓人繳納出資實際情況的考察，也是十分必要的。

3、虛假出資瑕疵中的法律風險。即股東根本未出資，採用欺騙手段獲得登記機關的信任。在發生虛假出資的情況下，該股東不僅應補足出資，而且還要承擔行政處罰的法律責任。

『肆』 首次適應演算法是什麼

First-fit (FF)是一種用於裝箱的在線演算法。

它的輸入是一個不同大小的項目列表。它的輸出是一個包裝——將物品分成固定容量的箱子，這樣每個箱子中物品的大小之和最多就是容量。理想情況下，我們希望使用盡可能少的 bin，但是最小化 bin 的數量是一個 NP-hard 問題。首次擬合演算法使用以下啟發式：

它保留一個打開的垃圾箱列表，最初是空的。

當一件物品到達時，它會找到該物品可以放入 的第一個箱子（如果有的話）。

如果找到這樣的箱子，則將新物品放入其中。

否則，將打開一個新的箱子並將即將到來的物品放入其中。

優缺點

1、優點

處理速度快。由於處理器將最近的可用內存分區分配給作業，因此執行速度非常快。

2、缺點

浪費大量內存。處理器忽略分配給作業的分區大小與作業大小相比是否非常大。它只是分配內存。結果，浪費了大量內存，許多作業可能無法在內存中獲得空間，並且必須等待另一個作業完成。

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

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

『陸』 連續分配存儲管理方式

一、單一連續分配

最簡單的一種存儲管理方式，只能用於單用戶、單任務的操作系統中。

優點：易於管理。

缺點：對要求內存空間少的程序，造成內存浪費；程序全部裝入，很少使用的程序部分也佔用內存。

二、固定分區分配

把內存分為一些大小相等或不等的分區(partition)，每個應用進程佔用一個分區。操作系統佔用其中一個分區。支持多個程序並發執行，適用於多道程序系統和分時系統。最早的多道程序存儲管理方式。

缺點：內碎片（一個分區內的剩餘空間）造成浪費；劃分為幾個分區，便只允許幾道作業並發，分區總數固定，限制並發執行的程序數目。

三、動態分區分配

1、分區的大小不固定：在裝入程序時根據進程實際需要，動態分配內存空間，即——需要多少劃分多少。

2、空閑分區表項：從1項到n項：內存會從初始的一個大分區不斷被劃分、回收從而形成內存中的多個分區。

3、優點：並發進程數沒有固定數的限制，不產生內碎片。缺點：有外碎片（分區間無法利用的空間）

4、分區分配演算法

①首次適應演算法FF(first-fit)

空閑分區排序：以地址遞增的次序鏈接。

檢索：分配內存時，從鏈首開始順序查找直至找到一個大小能滿足要求的空閑分區；

分配：從該分區中劃出一塊作業要求大小的內存空間分配給請求者，餘下的空閑分區大小改變仍留在空閑鏈中。

若從頭到尾檢索不到滿足要求的分區則分配失敗

優點：優先利用內存低址部分，保留了高地址部分的大空閑區；

缺點：但低址部分不斷劃分，會產生較多小碎片；而且每次查找從低址部分開始，會逐漸增加查找開銷。

②循環首次適應演算法

空閑分區排序：按地址

檢索：從上次找到的空閑分區的下一個空閑分區開始查找，直到找到一個能滿足要求的空閑分區。為實現演算法，需要設置一個起始查尋指針並採用循環查找方式

分配：分出需要的大小

優點：空閑分區分布均勻，減少查找開銷

缺點：缺乏大的空閑分區

③最佳適應演算法

總是把能滿足要求、又是最小的空閑分區分配給作業，避免「大材小用」。

空閑分區排序：所有空閑分區按容量從小到大排序成空閑分區表或鏈。

檢索：從表或鏈的頭開始，找到的第一個滿足的就分配

分配：分出需要的大小

缺點：每次找到最合適大小的分區割下的空閑區也總是最小，會產生許多難以利用的小空閑區（外碎片）

④最差適應演算法/最壞匹配法

基本不留下小空閑分區，但會出現缺乏較大的空閑分區的情況。

⑤快速適應演算法

根據進程常用空間大小進行劃分，相同大小的串成一個鏈，需管理多個各種不同大小的分區的鏈表。進程需要時，從最接近大小需求的鏈中摘一個分區。

能快速找到合適分區，但鏈表信息會很多；實際上是空間換時間。

5、回收分區

(1)回收區（首址a）與一個分區f1末尾（首址b+大小）鄰接：將回收區與f1合並，修改f1的表項的分區大小

(2)回收區（首址a+大小）與一個分區f2的首址b鄰接：將回收區與f2合並，修改f2的表項的首址、分區大小

(3) （1）（2）兩種情況都有，則將回收區與前後兩個分區F1、F2鄰接：將三個分區合並，使用F1的表項和F1的首址，取消F2的表項，大小為三者之和

(4) 回收區沒有鄰接的分區：為回收區單獨建立新表項，填寫回收區的首址與大小，根據其首址插到空閑鏈中的適當位置

四、動態重定位分區分配——有緊湊功能的動態分區分配

動態重定位分區分配演算法與動態分區分配演算法基本相同，差別在於增加了緊湊的功能。

夥伴系統

分區大小有規定，且分區動態變化

1、無論已分配還是空閑分區，大小都為2的k此冪。若整個可分配空間大小為2m，則1≤k≤m.

2、隨著系統運行，內存被不斷劃分，形成若干不連續的空閑分區。對每一類具有相同大小的空閑分區設置一雙向鏈表，即會有k個鏈表，鏈表中的分區大小都是2m。

3、進程申請n個大小的空間時，計算n= 2i。則找i對應的鏈表。若i大小的鏈表沒有，則找i+1的鏈表。找到的分區對半劃分後，一半用於分配，一半鏈接到較小一級的鏈表裡去。

4、一次分配和回收都可能對應多次的劃分和合並。

五、內存空間管理之對換

當內存空間還是滿足不了需求時，把內存中暫時不能運行、或暫時不用的程序和數據調到外存上，以騰出足夠的內存；把已具備運行條件的進程和進程所需要的程序和數據，調入內存。

整體對換(或進程對換)：以整個進程為單位（連續分配）

頁面對換或分段對換：以頁或段為單位（離散分配）

『柒』 求用C語言寫出首次適應分配演算法的分配過程~

/********************************
內存管理模擬程序
*******************************/
#include<iostream.h>
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include <time.h>
#include <windows.h>
/*定義宏*/
#define TotalMemSize 1024 /*劃分的物理塊的大小，地址范圍0~1023*/
#define MinSize 2 /*規定的不再分割的剩餘分區的大小*/
#define getpch(type) (type*)malloc(sizeof(type))

/*定義內存塊*/
typedef struct memBlock
{
struct memBlock *next;/*指向下一個塊*/
int stAddr; /*分區塊的初始地址*/
int memSize; /*分區塊的大小*/
int status; /*分區塊的狀態，0：空閑，1：以被分配*/
}MMB;

/*定義全局變數*/
MMB *idleHead=NULL; /*空閑分區鏈表的頭指針*/
MMB *usedHead=NULL; /*分配分區鏈表的頭指針*/
MMB *usedRear=NULL; /*分配分區鏈表的鏈尾指針*/
MMB *np; /*循環首次適應演算法中指向即將被查詢的空閑塊*/

int idleNum=1;/*當前空閑分區的數目*/
int usedNum=0;/*當前已分配分區的數目*/

MMB *memIdle=NULL; /*指向將要插入分配分區鏈表的空閑分區*/
MMB *memUsed=NULL; /*指向將要插入空閑分區鏈表的已分配分區*/

int flag=1;/*標志分配是否成功，1：成功*/

/*函數聲明*/
void textcolor (int color);/*輸出著色*/
void InitMem();/*初始化函數*/
int GetUseSize(float miu,float sigma); /*獲得請求尺寸*/

MMB *SelectUsedMem(int n);/*選擇待釋放的塊*/

void AddToUsed();/*將申請到的空閑分區加到分配分區鏈表中*/
int RequestMemff(int usize); /*請求分配指定大小的內存,首次適應演算法*/
int RequestMemnf(int usize); /*請求分配指定大小的內存,循環首次適應演算法*/

void AddToIdle();/*將被釋放的分配分區加到空閑分區鏈表中(按地址大小）*/
void ReleaseMem(); /*釋放指定的分配內存塊*/

/*主函數*/
void main()
{
int sim_step;
float miu,sigma; /*使隨機生成的請求尺寸符合正態分布的參數*/
int i;
int a;

MMB *p;
/* double TotalStep=0,TotalSize=0,TotalRatio=0,TotalUSize=0,Ratio=0,n=0;
double aveStep=0,aveSize=0,aveRatio=0;
int step=0,usesize=0; */
textcolor(11);
printf("\n\t\t內存管理模擬程序\n\n");
/* InitMem();*/
while(true)
{
double TotalStep=0,TotalSize=0,TotalRatio=0,TotalUSize=0,Ratio=0,n=0;
double aveStep=0,aveSize=0,aveRatio=0;
int step=0,usesize=0;
InitMem();
textcolor(12);
printf("\n\n首次適應演算法： 0");
printf("\n循環首次適應演算法： 1\n");
textcolor(11);
printf("\n請選擇一種演算法：");
scanf("%d",&a);
textcolor(15);
printf("\n輸入一定數量的步數：(sim_step)");
scanf("%d",&sim_step);
printf("\n 輸入使隨機生成的請求尺寸符合正態分布的參數：miu,sigma ");
scanf("%f,%f",&miu,&sigma);
for(i=1;i<=sim_step;i++)
{
textcolor(10);
printf("\n\n#[%d]\n",i);
do{
usesize=GetUseSize(miu,sigma);
while((usesize<0)||(usesize>TotalMemSize))
{
usesize=GetUseSize(miu,sigma);
}
textcolor(13);
printf("\n\n申請的內存尺寸為：%d",usesize);
printf("\n此時可用的空閑分區有 %d 塊情況如下：",idleNum);
p=idleHead;
textcolor(15);
while(p!=NULL)
{
printf("\n始址:%d\t 尺寸：%d",p->stAddr,p->memSize);
p=p->next;
}
TotalSize+=usesize;
if(a==0)
step=RequestMemff(usesize);
else
step=RequestMemnf(usesize);
TotalStep+=step;
n++;
}while(flag==1);
p=usedHead;
while(p!=NULL)
{
TotalUSize+=p->memSize;
printf("\n始址:%d\t 尺寸：%d",p->stAddr,p->memSize);
p=p->next;
}
textcolor(11);
if(TotalUSize!=0)
{
Ratio=TotalUSize/TotalMemSize;
TotalUSize=0;
printf("\n內存利用率NO.%d :%f%c",i,100*Ratio,'%');
}
else
{
Ratio=0;
printf("\n內存利用率NO.%d :%c%c",i,'0','%');
}
TotalRatio+=Ratio;
ReleaseMem();
}
if(n!=0)
{
textcolor(10);
aveStep=TotalStep/n;
aveSize=TotalSize/n;
aveRatio=TotalRatio/sim_step;
printf("\n平均搜索步驟：%f",aveStep);
printf("\n平均請求尺寸：%f",aveSize);
printf("\n平均內存利用率：%f",aveRatio);
}
}
}
// 輸出著色 /////////////////////////////////////////
void textcolor (int color)
{
SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color );
}

/******************************
函數名：InitMem()
用途：把內存初始化為一整塊空閑塊
****************************************/
void InitMem()
{
MMB *p;
p=getpch(MMB);
p->memSize=TotalMemSize;
p->stAddr=0;
p->status=0;
p->next=NULL;
idleHead=p;
np=idleHead;
usedHead=NULL;
usedRear=NULL;
idleNum=1;
usedNum=0;
flag=1;
memIdle=NULL;
memUsed=NULL;

}

/******************************
函數名：GetUseSize(float miu,float sigma)
用途：獲得請求尺寸；
參數說明：float miu,float sigma ：正態分布的參數
返回值:申請尺寸的大小；
****************************************************/
int GetUseSize(float miu,float sigma)
{
float r1,r2;
float u,v,w;
float x,y;
do
{
r1=rand()/32767.0;
r2=rand()/32767.0;

u=2*r1-1;
v=2*r2-1;

w=u*u+v*v;
}while(w>1);
x=u*sqrt(((-log(w))/w));
y=v*sqrt(((-log(w))/w));
return miu+sigma*x;
}

/******************************
函數名：*SelectUsedMem(int n)
用途：選擇待釋放的塊(0~n-1)
返回值：指向待釋放的塊的指針；
****************************************************/
MMB *SelectUsedMem(int n)
{
MMB *p;
int i,j;
if(n>0)
{
i = rand()%n ;
textcolor(5);
printf("\n\n當前已分配分區總數為：%d",n);
printf("\n待釋放塊的序號為：%d\n",i );
p=usedHead;
if(p!=NULL)
{
for(j=i;j>0;j--)
p=p->next;
return(p);
}
else
return(NULL);
}
else
{
printf("\n當前沒有可釋放的資源！\n");
}
}
/******************************
函數名：AddToUsed()
用途：將申請到的空閑分區加到分配分區鏈表中
***************************************************************/
void AddToUsed()
{
MMB *p;
memIdle->status=1;
if(usedHead==NULL)
{
usedHead=memIdle;
usedRear=usedHead;

}
else
{
usedRear->next=memIdle;
usedRear=memIdle;
}
usedNum++;
printf("\n當前分配分區共有%d塊！",usedNum);
p=usedHead;
while(p!=NULL)
{
printf("\n始址:%d \t 尺寸：%d",p->stAddr,p->memSize);
p=p->next;
}
}
/******************************
函數名：RequestMemff(int usize)
參數說明：usize：請求尺寸的大小；
用途：請求分配指定大小的內存,首次適應演算法
返回值：搜索步驟
***************************************************************/
int RequestMemff(int usize)
{
MMB *p1,*p2,*s;
int step;
int suc=0;
int size1,size2;

if(idleHead==NULL)
{
flag=0;
textcolor(12);
printf("\n分配失敗！");
return 0;
}
else
{
if((idleHead->memSize)>usize)
{
size1=(idleHead->memSize)-usize;
if(size1<=MinSize)
{
memIdle=idleHead;

idleHead=idleHead->next;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=idleHead->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;

idleHead->memSize=idleHead->memSize-usize;
idleHead->stAddr=idleHead->stAddr+usize;
}
step=1;
flag=1;
textcolor(12);
printf("\n分配成功！");
AddToUsed();

}
else
{
p1=idleHead;
step=1;
p2=p1->next;
while(p2!=NULL)
{
if((p2->memSize)>usize)
{
size2=(p2->memSize)-usize;
if(size2<=MinSize)
{
p1->next=p2->next;
memIdle=p2;
memIdle->next=NULL;
idleNum--;

}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=p2->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
p2->memSize=p2->memSize-usize;
p2->stAddr=p2->stAddr+usize;

}
flag=1;
suc=1;
textcolor(12);
printf("\n分配成功！");
AddToUsed();
p2=NULL;
}
else
{
p1=p1->next;
p2=p2->next;
step++;
}
}
if(suc==0)
{
flag=0;
textcolor(12);
printf("\n分配失敗！");
}
}
}
return step;
}

/******************************
函數名：AddToIdle()
用途：將被釋放的分配分區加到空閑分區鏈表中(按地址遞增順序排列）
***************************************************************/
void AddToIdle()
{
MMB *p1,*p2;
int insert=0;
if((idleHead==NULL))
{
idleHead=memUsed;
idleNum++;
np=idleHead;
}
else
{
int Add=(memUsed->stAddr)+(memUsed->memSize);
if((memUsed->stAddr<idleHead->stAddr)&&(Add!=idleHead->stAddr))
{
memUsed->next=idleHead;
idleHead=memUsed;
idleNum++;
}
else
{

if((memUsed->stAddr<idleHead->stAddr)&&(Add==idleHead->stAddr))
{
idleHead->stAddr=memUsed->stAddr;
idleHead->memSize+=memUsed->memSize;

}
else
{
p1=idleHead;
p2=p1->next;
while(p2!=NULL)
{
if(memUsed->stAddr>p2->stAddr)
{
p1=p1->next;
p2=p2->next;
}
else
{
int Add1=p1->stAddr+p1->memSize;
int Add2=p2->stAddr-memUsed->memSize;
if((Add1==memUsed->stAddr)&&(memUsed->stAddr!=Add2))
{
p1->memSize=p1->memSize+memUsed->memSize;
}
if((Add1!=memUsed->stAddr)&&(memUsed->stAddr==Add2))
{
p2->memSize=p2->memSize+memUsed->memSize;
p2->stAddr=memUsed->stAddr;
}
if((Add1!=memUsed->stAddr)&&(memUsed->stAddr!=Add2))
{
memUsed->next=p2;
p1->next=memUsed;
if(np->stAddr==p2->stAddr)
np=p1->next;
idleNum++;
}
if((Add1==memUsed->stAddr)&&(memUsed->stAddr==Add2))
{
p1->memSize=p1->memSize+memUsed->memSize+p2->memSize;
p1->next=p2->next;
if((np->stAddr)==(p2->stAddr))
np=p1;
idleNum--;
}
p2=NULL;
insert=1;
}
}
if(insert==0)
{
p1->next=memUsed;
idleNum++;
}
}
}
}
}

/******************************
函數名：ReleaseMem()
用途：釋放指定的分配內存塊
***************************************************************/
void ReleaseMem()
{
MMB *q1,*q2;
MMB *s;
if(usedNum==0)
{
printf("\n當前沒有分配分區!");
return;
}
else
{
s=SelectUsedMem(usedNum);
if(s!=NULL)
{

if(s->stAddr==usedHead->stAddr)
{
memUsed=usedHead;
usedHead=usedHead->next;
memUsed->next=NULL;
AddToIdle();
usedNum--;
}
else
{
q1=usedHead;
q2=q1->next;
while(q2!=NULL)
{
if(q2->stAddr!=s->stAddr)
{
q1=q1->next;
q2=q2->next;
}
else
{
q1->next=q2->next;
memUsed=q2;
memUsed->next=NULL;
if(q1->next==NULL)
usedRear=q1;
AddToIdle();
usedNum--;
q2=NULL;
}
}
}
}
}
}

/******************************
函數名：RequestMemnf(int usize)
參數說明：usize：請求尺寸的大小；
用途：請求分配指定大小的內存,循環首次適應演算法
返回值：搜索步驟
***************************************************************/
int RequestMemnf(int usize)
{
MMB *p2,*p,*s;
int step;
int iNum=0;
int suc=0;
int size1,size2,size3;

if(idleHead==NULL)
{
flag=0;
printf("\n分配失敗！");
return 0;
}
else
{
iNum=idleNum;
while(iNum>0)
{
iNum--;
if((np->memSize)>usize)
{
/*指針指向的空閑塊滿足條件,且正好為頭指針*/
if(np->stAddr==idleHead->stAddr)
{
size1=(idleHead->memSize)-usize;
if(size1<=MinSize)
{
memIdle=idleHead;
idleHead=idleHead->next;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=idleHead->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
idleHead->memSize=idleHead->memSize-usize;
idleHead->stAddr=idleHead->stAddr+usize;
}
if((idleHead==NULL)||(idleHead->next==NULL))
np=idleHead;
else
np=idleHead->next;

}
else/*指針指向的空閑塊滿足條件,不為頭指針*/
{
size2=(np->memSize)-usize;
if(size2<=MinSize) /*從空閑鏈表中刪除*/
{
p=idleHead;
while(p->next->stAddr!=np->stAddr)
p=p->next;
p->next=np->next;
memIdle=np;
memIdle->next=NULL;
np=p;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=np->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;

np->memSize=np->memSize-usize;
np->stAddr=np->stAddr+usize;
}
if(np->next==NULL)
np=idleHead;
else
np=np->next;
}
step=1;
flag=1;
suc=1;
textcolor(12);
printf("\n分配成功！");
AddToUsed();
iNum=0;
}
else /*當前指針指向的空閑區不滿足條件*/
{
step=1;
p2=np->next;
if(p2==NULL)
{
np=idleHead;
iNum--;
}
else
{
if((p2->memSize)>usize)
{
size3=(p2->memSize)-usize;
if(size3<=MinSize)
{
np->next=p2->next;
memIdle=p2;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=p2->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
p2->memSize=p2->memSize-usize;
p2->stAddr=p2->stAddr+usize;
}
flag=1;
suc=1;
printf("\n分配成功！");
AddToUsed();
if(p2->next==NULL)
np=idleHead;
else
np=p2->next;
p2=NULL;
iNum=0;
}
else
{
np=np->next;
p2=p2->next;
iNum--;
step++;
}
}
}
// iNum--;
}
if(suc==0)
{
flag=0;
textcolor(12);
printf("\n分配失敗！");
}
}
return step;
}

『捌』 什麼是最優適應分配演算法

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

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

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

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

『玖』 在動態分區分配方式中，可利用哪些分區分配演算法

動態分區分配演算法：
1.首次適應演算法（FF/first fit）
2.循環首次適應演算法（next fit）
3.最佳適應演算法（best fit）
從最小的分區開始分配
4.最壞適應演算法（worst fit）
從最大的分區開始分配
5.快速適應演算法/分類搜索法(quick fit)
將空閑分區根據其容量的大小進行分類