三种内存分配算法总结及代码实现
- 首次适应算法
- 最坏适应算法
- 最佳适应算法
- 代码实现
首次适应算法
找第一个满足大小的空闲分区
该算法从空闲分区链首开始查找，直至找到一个能满足其大小要求的空闲分区为止。然后再按 照作业的大小，从该分区中划出一块内存分配给请求者，余下的空闲分区仍留在空闲分区链中
- 优点： 该算法倾向于使用内存中低地址部分的空闲区，在高地址部分的空闲区很少被利用，从而保留了高地址部分的大空闲 区。显然为以后到达的大作业分配大的内存空间创造了条件
- 缺点：低地址部分不断被划分，留下许多难以利用、很小的空闲区，而每次查找又都从低地址部分开始，会增加查找的开销
核心代码：
for (i = 0; i < MEMSIZE - 1 && MemList[i].info != 'e'; i++)
{
//满足所需要的大小，且是空闲空间
if (MemList[i].size >= size && MemList[i].info == 'f')
{
if (MemList[i].size - size <= MINSIZE)
{
MemList[i].info = 'u';
}
else
{ //将i后的信息表元素后移
for (j = MEMSIZE - 2; j > i; j--)
{
MemList[j + 1] = MemList[j];
}
//将i分成两部分，使用低地址部分
MemList[i + 1].start = MemList[i].start + size;
MemList[i + 1].size = MemList[i].size - size;
MemList[i + 1].info = 'f';
MemList[i].size = size;
MemList[i].info = 'u';
}
break;
}
}最坏适应算法
找最大的满足大小的空闲分区
该算法按大小递减的顺序形成空闲区链，分配时直接从空闲区链的第一个空闲区中分配（不能 满足需要则不分配）。很显然，如果第一个空闲分区不能满足，那么再没有空闲分区能满足需要。这种分配方法初看起来不太合理，但它也有很强的直观吸引力：在大空闲区中放入程序后，剩下的空闲区常常也很大，于是还能装下一个较大的新程序。最坏适应算法与最佳适应算法的排序正好相反，它的队列指针总是指向最大的空闲区，在进行分配时，总是从最大的空闲 区开始查寻。该算法克服了最佳适应算法留下的许多小的碎片的不足，但保留大的空闲区的可能性减小了，而且空闲区回收也和最佳适应算法一样复杂。
- 优点：给文件分配分区后剩下的空闲区不至于太小，产生碎片的几率最小，对中小型文件分配分区操作有利。
- 缺点：使存储器中缺乏大的空闲区，对大型文件的分区分配不利。
核心代码：
j = 0;
flag = 0;
k = 0;
//保存满足要求的最大空间
for (i = 0; i < MEMSIZE - 1 && MemList[i].info != 'e'; i++)
{
if (MemList[i].size >= size && MemList[i].info == 'f')
{
flag = 1;
if (MemList[i].size > k)
{
k = MemList[i].size;
j = i;
}
}
}
for (j = MEMSIZE - 2; j > i; j--)
{
MemList[j+1]=MemList[j];
}
MemList[i+1].start=MemList[i].start+size;
MemList[i+1].size=MemList[i].size-size;
MemList[i+1].info='f';
MemList[i].size=size;
MemList[i].info='u';最佳适应算法
找最小的满足大小的空闲分区
该算法总是把既能满足要求，又是最小的空闲分区分配给作业。为了加速查找，该算法要求将 所有的空闲区按其大小排序后，以递增顺序形成一个空白链。这样每次找到的第一个满足要求的空闲区，必然是最优的。孤立地看，该算法似乎是最优的，但事实上并不一定。因为每次分配后剩余的空间一定是最小的，在存储器中将留下许多难以利用的小空闲区。同时每次分配后必须重新排序，这也带来了一定的开销。
- 优点：每次分配给文件的都是最合适该文件大小的分区。
- 缺点：内存中留下许多难以利用的小的空闲区。
核心代码
j=0;
flag=0;
k=MEMSIZE;
for (i = 0; i < MEMSIZE-1&&MemList[i].info!='e'; i++)
{
if(MemList[i].size>=size&&MemList[i].info=='f')//符合要求
{
flag=1;
if (MemList[i].size
}
}
for ( j = MEMSIZE-2; j > i; j--)
{
MemList[j+1]=MemList[j];
}
MemList[i+1].start=MemList[i].start+size;
MemList[i+1].size=MemList[i].size-size;
MemList[i+1].info='f';
MemList[i].size=size;
MemList[i].info='u'; 代码实现
#include 1&&MemList[i].info!='e';i++)
{
if(i>0)
MemList[i]=MemList[i+1];
}
}
//左空间空闲则合并
if (number>0&&MemList[number-1].info=='f')
{
MemList[number-1].size+=MemList[number].size;
for(i=number;i1&&MemList[i].info!='e';i++)
MemList[i]=MemList[i+1];
}
}
else
{
printf("This Number is NOT exist or is Not used!\n");
getchar();
}
Dispaly();
}
/*
函数名：BestFit_new()
功能：最佳适应算法分配内存
*/
void BestFit_new()
{
int i,j,k,flag,size;
char temp[10];
printf("BestFit_new How many MEMORY require?");
scanf("%d",&size);
j=0;
flag=0;
k=MEMSIZE;
for (i = 0; i < MEMSIZE-1&&MemList[i].info!='e'; i++)
{
if(MemList[i].size>=size&&MemList[i].info=='f')//符合要求
{
flag=1;
if (MemList[i].size//比符合要求的最小空间小，则交换
{
k=MemList[i].size;
j=i;
}
}
}
i=j;
if(flag==0)//没找到
{
printf("Not Enough Memory!\n");
getchar();
j=i;
}
else if (MemList[i].size-size<=MINSIZE)
{
MemList[i].info='u';
}
else
{
for ( j = MEMSIZE-2; j > i; j--)
{
MemList[j+1]=MemList[j];
}
MemList[i+1].start=MemList[i].start+size;
MemList[i+1].size=MemList[i].size-size;
MemList[i+1].info='f';
MemList[i].size=size;
MemList[i].info='u';
}
Dispaly();
}
/*
函数名：main()
*/
int main(int argc, char const *argv[])
{
char ch;
InitAll();
while(1)
{
printf("============================================================\n");
printf(" 1.Get a block use the FIRSTFIT method\n");
printf(" 2.Get a block use the BESTFIT method\n");
printf(" 3.Get a block use the BADFIT method\n");
printf(" 4.Free a block\n");
printf(" 5.Display Mem info \n");
printf(" 6.Exit\n");
printf("============================================================\n");
ch=getchar();
switch(ch)
{
case '1':
FirstFit_new();
break;
case '2':
BestFit_new();
break;
case '3':
BadFit_new();
break;
case '4':
del();
break;
case '5':
Dispaly();
break;
case '6':
return 0;
}
}
return 0;
}
参考： https://blog.csdn.net/u011070169/article/details/53177987