首次分配算法

‘壹’ 求助：简述可变分区存储管理系统中采用循环首次适应法的分配算法的思想

首次适应法:
即第一次适应。比如有空闲区按顺序如下：
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)
将空闲分区根据其容量的大小进行分类