c模擬內存分配算法（首次適應算法，最佳適應算法，最壞適應算法）

#include<bits/stdc++.h>
using namespace std;
/*定義內存的大小為100*/
#define MEMSIZE 100
/*如果小於此值，將不再分割內存*/
#define MINSIZE 2

/*內存分區空間表結構*/
typedef struct _MemoryInfomation
{
    /*起始地址*/
    int start;
    /*大小*/
    int Size;
    /*狀態 F:空閑(Free) U:占用(Used) E 結束(End)*/
    char status;
} MEMINFO;

/*內存空間信息表*/
MEMINFO MemList[MEMSIZE];

/*顯示內存狀態*/
void Display()
{
    int i,used=0;//記錄可以使用的總空間量
    printf("\n---------------------------------------------------\n");
    printf("%5s%15s%15s%15s","Number","start","size","status");
    printf("\n---------------------------------------------------\n");
    for(i=0; i<MEMSIZE&&MemList[i].status!='e'; i++)
    {
        if(MemList[i].status=='u')
        {
            used+=MemList[i].Size;
        }
        printf("%5d%15d%15d%15s\n",i,MemList[i].start,MemList[i].Size,MemList[i].status=='u'?"USED":"FREE");
    }
    printf("\n----------------------------------------------\n");
    printf("Totalsize:%-10d Used:%-10d Free:%-10d\n",MEMSIZE,used,MEMSIZE-used);
}

/*初始化所有變量*/
void InitMemList()
{
    int i;
    MEMINFO temp= {0,0,'e'};
    //初始化空間信息表
    for(i=0; i<MEMSIZE; i++)
    {
        MemList[i]=temp;
    }
    //起始地址為0
    MemList[0].start=0;
    //空間初始為最大
    MemList[0].Size=MEMSIZE;
    //狀態為空閑
    MemList[0].status='f';
}

/*最先適應算法*/

/*算法原理分析：
將空閑的內存區按其在儲存空間中的起始地址遞增的順序排列，為作業分配儲存空間時，從空閑區鏈的始端開始查找，選擇第一個滿足要求的空閑區，而不管它究竟有多大

優點:
1.在釋放內存分區的時候，如果有相鄰的空白區就進行合並，使其成為一個較大的空白區
2.此算法的實質是盡可能的利用儲存器的低地址部分，在高地址部分則保留多的或較大的空白區，以后如果需要較大的空白區，就容易滿足

缺點：
1.在低地址部分很快集中了許多非常小的空白區，因而在空白區分配時，搜索次數增加，影響工作效率。*/


void FirstFit_new()
{
    int i,j,flag=0;
    int request;
    printf("FirstFit_new:How Many MEMORY requir?\n");
    scanf("%d",&request);
    //遍歷數組
    for(i=0; i<MEMSIZE&&MemList[i].status!='e'; i++)
    {
        //滿足所需要的大小,且是空閑空間
        if(MemList[i].Size>=request&&MemList[i].status=='f')
        {
            //如果小於規定的最小差則將整個空間分配出去
            if(MemList[i].Size-request<=MINSIZE)
            {
                MemList[i].status='u';
            }
            else
            {
                //將i后的信息表元素后移
                for(j=MEMSIZE-2; j>i; j--)
                {
                    MemList[j+1]=MemList[j];
                }

                //將i分成兩部分，使用低地址部分
                MemList[i+1].start=MemList[i].start+request;
                MemList[i+1].Size=MemList[i].Size-request;
                MemList[i+1].status='f';
                MemList[i].Size=request;
                MemList[i].status='u';
                flag=1;
            }
            break;
        }
    }
    //沒有找到符合分配的空間
    if(flag!=1||i==MEMSIZE||MemList[i].status=='e')
    {
        printf("Not Enough Memory!!\n");
    }
    Display();
}
/*最壞適應算法

算法原理分析：
掃描整個空閑分區或者鏈表，總是挑選一個最大的空閑分區分割給作業使用

優點：可以使得剩下的空閑分區不至於太小，產生碎片的幾率最小，對中小作業有利，同時該算法的查找效率很高

缺點：會使得儲存器中缺乏大的空閑分區
*/
void BadFit_new()
{
    int i,j,k,flag,request;
    printf("BadFit_new:How Many MEMORY requir?\n");
    scanf("%d",&request);
    j=0;
    flag=0;
    k=0;
    //保存滿足要求的最大空間
    for(i=0;i<MEMSIZE-1&&MemList[i].status!='e';i++)
    {
        if(MemList[i].Size>=request&&MemList[i].status=='f')
        {
            flag=1;
            if(MemList[i].Size>k)
            {
                k=MemList[i].Size;
                j=i;
            }
        }
    }
    i=j;
    if(flag==0)
    {
        printf("Not Enough Memory!\n");
        j=i;
    }else if(MemList[i].Size-request<=MINSIZE)
    {
        MemList[i].status='u';
    }else
    {
        for(j=MEMSIZE-2;j>i;j--)
        {
            MemList[j+1]=MemList[j];
        }
        MemList[i+1].start=MemList[i].start+request;
        MemList[i+1].Size=MemList[i].Size-request;
        MemList[i+1].status='f';
        MemList[i].Size=request;
        MemList[i].status='u';
    }
    Display();
}


//釋放一塊內存
void del_t()
{
    int i,number;
    printf("\nplease input the NUMBER you want stop:\n");
    scanf("%d",&number);
    //輸入的空間是使用的
    if(MemList[number].status=='u')
    {
        MemList[number].status='f';//標志為空閑
        if(MemList[number+1].status=='f')//右側空間為空則合並
        {
            MemList[number].Size+=MemList[number].Size;//大小合並
            for(i=number+1; i<MEMSIZE-1&&MemList[i].status!='e'; i++) //i后面的空間信息表元素后移
            {
                if(i>0)
                {
                    MemList[i]=MemList[i+1];
                }
            }
        }
        //左測空間空閑則合並
        if(number>0&&MemList[number-1].status=='f')
        {
            MemList[number-1].Size+=MemList[number].Size;
            for(i=number; i<MEMSIZE-1&&MemList[i].status!='e'; i++)
            {
                MemList[i]=MemList[i+1];
            }
        }
    }
    else
    {
        printf("This Number is Not Exist or is Not Used！\n");
    }
    Display();
}

/*最佳適應算法

算法原理分析：
從全部空閑區中找出滿足作業要求的，且大小最小的空閑分區的一種計算方法，這種方法能使得碎片盡量小，為適應此算法，空閑分區表中的空閑分區要按從小到大進行排序，自表頭開始查找第一個滿足要求的自由分區分配

優點：能使得碎片盡量的小,保留了最大空閑區

缺點：造成了許多小的空閑區
*/
void BestFit_new()
{
    int i,j,t,flag,request;
    printf("BestFit_new How Many MEMORY requir?\n");
    scanf("%d",&request);
    j=0;
    flag=0;
    t=MEMSIZE;
    //保存滿足要求的最大空間
    for(i=0; i<MEMSIZE&&MemList[i].status!='e'; i++)
    {
        if(MemList[i].Size>=request&&MemList[i].status=='f')
        {
            flag=1;
            if(MemList[i].Size<t)
            {
                t=MemList[i].Size;
                j=i;
            }
        }
    }
    i=j;
    if(flag==0)
    {
        printf("Not Enough Memory!\n");
        j=i;
    }
    else if(MemList[i].Size-request<=MINSIZE)  //如果小於規定的最小差則將整個空間分配出去
    {
        MemList[i].status='u';
    }
    else
    {
        //將i后的信息表元素后移
        for(j=MEMSIZE-2; j>i; j--)
        {
            MemList[j+1]=MemList[j];
        }

        //將i分成兩部分，使用低地址部分
        MemList[i+1].start=MemList[i].start+request;
        MemList[i+1].Size=MemList[i].Size-request;
        MemList[i+1].status='f';
        MemList[i].Size=request;
        MemList[i].status='u';
    }
    Display();
}

int main()
{
    int x;
    InitMemList();//變量初始化
    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.Dispaly Mem info \n");
        printf("         6.Exit \n");
        printf("=================================================\n");
        scanf("%d",&x);
        switch(x)
        {
        case 1:
            FirstFit_new();//首次適應算法
            break;
        case 2:
            BestFit_new();//最佳適應算法
            break;
        case 3:
            BadFit_new();//最壞適應算法
            break;
        case 4:
            del_t();//刪除已經使用完畢的空間
            break;
        case 5:
            Display();//顯示內存分配情況
            break;
        case 6:
            exit(0);
        }
    }
    return 0;
}