三种内存分配算法总结及代码实现

版权声明:本文为博主原创文章,转载请注明出处,谢谢! https://blog.csdn.net/xp731574722/article/details/80341659

首次适应算法

找第一个满足大小的空闲分区

该算法从空闲分区链首开始查找,直至找到一个能满足其大小要求的空闲分区为止。然后再按 照作业的大小,从该分区中划出一块内存分配给请求者,余下的空闲分区仍留在空闲分区链中

  • 优点: 该算法倾向于使用内存中低地址部分的空闲区,在高地址部分的空闲区很少被利用,从而保留了高地址部分的大空闲 区。显然为以后到达的大作业分配大的内存空间创造了条件
  • 缺点:低地址部分不断被划分,留下许多难以利用、很小的空闲区,而每次查找又都从低地址部分开始,会增加查找的开销

核心代码:

    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<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';

代码实现

#include <stdio.h>
#include <stdlib.h>
#include <cstring>
/*定义内存大小为100*/
#define MEMSIZE 100
/*如果小于此值 将不再分割内存*/
#define MINSIZE 2

/*内存空间分区表 结构*/
typedef struct _MemoryInfomation
{
    int start; //起始地址
    int size;  //大小
    char info; //状态 F:空闲(Free) U:占用(Used) E结束(End)*/
} MEMINFO;

//内存空间信息表
MEMINFO MemList[MEMSIZE];

/*--------------------------------
函数名:Display()
功能:显示内存状态
----------------------------------*/
void Dispaly()
{
    int i,
        used = 0;
    /* clrscr();*/
    printf("\n--------------------------------------------\n");
    printf("%5s%15s%15s%15s", "No", "start", "size", "Info");
    printf("\n---------------------------------------------\n");
    for (int i = 0; i < MEMSIZE && MemList[i].info != 'e'; i++)
    {
        if (MemList[i].info == 'u')
        {
            used += MemList[i].size;
        }
        printf("%5d%15d%15d%15s\n", i, MemList[i].start, MemList[i].size, MemList[i].info == 'u' ? "USED" : "FREE");
    }
    printf("\n---------------------------------------------\n");
    printf("Totalsize:%-10d Used:%-10d Free:%-10d\n", MEMSIZE, used, MEMSIZE - used);
    printf("\n---------------------------------------------\n");
    getchar();
}

/*----------------------------
函数名:InitAll()
功能:初始化所有变量
----------------------------*/
void InitAll()
{
    int i;
    MEMINFO temp = {0, 0, 'e'};
    //初始化空间信息表
    for (int i = 0; i < MEMSIZE; i++)
    {
        MemList[i] = temp;
    }
    //初始化地址为0
    MemList[0].start = 0;
    //空间初始为最大的
    MemList[0].size = MEMSIZE;
    //状态为空闲
    MemList[0].info = 'f';
}

/*-----------------------------
函数名:FirstFit_new
功能:首次适应算法分配内存
------------------------------*/
void FirstFit_new()
{
    int i, j, size;
    char temp[10];
    printf("FirstFit_new:How many MEMORY require?");
    scanf("%d", &size);
    //到了空间尾且没有空间分配
    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;
        }
    }
    //没有找到符合分配的空间
    if (i == MEMSIZE - 1 || MemList[i].info == 'e')
    {
        printf("Not Enough Memory!\n");
        getchar();
    }
    Dispaly();
}
/*
最坏适应算法
*/
void BadFit_new()
{
    int i, j, k, flag, size;
    char temp[10];
    printf("BadFit_new How many MEMORY require?");
    scanf("%d", &size);
    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;
            }
        }
    }
    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();
}

/*
函数名:del()
功能:释放一块内存
*/
void del()
{
    int i,number;
    char temp[10];
    printf("\nplease input the NUMBER you want to stop:");
    scanf("%d",&number);
    if (MemList[number].info=='u')
    {
        MemList[number].info='f';//标志为空闲
        if (MemList[number+1].info=='f')//右空间空闲则合并
        {
            MemList[number].size+=MemList[number+1].size;
            for(i=number+1;i<MEMSIZE-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;i<MEMSIZE-1&&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)//比符合要求的最小空间小,则交换
            {
                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

阅读更多

扫码向博主提问

青龙指引你

非学,无以致疑;非问,无以广识
  • 擅长领域:
  • 算法
去开通我的Chat快问
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页