动态分区存储管理

实现了三个算法，首次适应，最佳和最坏，其实很简单，但是测得样例还是不多，有错误请指出！

大体思路，就是将内存看成一个个的结构体，每个结构体存放一段空间的起始位置和结束位置以及存储的作业ID。

初始情况时，内存为空，所以只有一个结构体，存放从1-n，ID为-1，这样当新的作业到来或者回收时，只需要将合适的结构体拆分或者合并，同时总的结构体数量增加或减少就可以了~~~~其实很简单吧

#include<bits/stdc++.h>
#define Max 1000001
using namespace std;

struct job
{
    int st;//起始地址
    int en;//结束地址
    int id;//作业号(为-1表示为空)
} a[Max];
int sum=0;//已存在的空间块
int n;//最大内存
int use_n;//已使用内存
void con()
{
    system("pause");
    system("cls");
}
void show()
{
    printf("当前内存使用情况\n");
    for(int i=1; i<=sum; i++)
    {
        printf("起始位置\t结束位置\t作业ID\n");
        printf("%d\t\t%d\t\t%d\n",a[i].st,a[i].en,a[i].id);
    }
}
void next(int x)
{
    /**向后移动一位**/
    for(int i=sum+1; i>x; i--)
        a[i] = a[i-1];
}
bool find_id(int id)
{
    /**查看当前作业号是否存在**/
    for(int i=1; i<=sum; i++)
    {
        if(a[i].id==id)
            return true;
    }
    return false;
}
void font(int x)
{
    /**合并之后，向前移动**/
    for(int i=x; i<=sum-1; i++)
    {
        a[i]=a[i+1];
    }
    sum--;
}
void hebing()
{
    /**合并连续的空闲空间**/
    for(int i=1; i<=sum; i++)
    {
        if(a[i].id==-1 && a[i-1].id==-1)
        {
            a[i-1].en = a[i].en;
            font(i);
        }
    }
    sum--;
}
void huishou()
{
    printf("请输入要回收的作业ID:");
    int id;
    scanf("%d",&id);
    if(find_id(id)==false)
    {
        printf("作业不存在\n");
        con();
        return;
    }
    for(int i=1; i<=sum; i++)
    {
        if(a[i].id==id)
        {
            a[i].id=-1;
            if(a[i-1].id==-1 || a[i+1].id==-1)
                hebing();//合并连续的空闲空间
            break;
        }
    }
    show();
}
void First_memery()
{
    while(1)
    {
        printf("当前为首次适应算法\n");
        int choose;
        printf("请选择操作项目：1、新到作业\t2、回收作业\t-1、退出:");
        scanf("%d",&choose);
        if(choose == -1)
            break;
        if(choose!=1&&choose!=2)
        {
            printf("输入错误请重新输入\n");
            con();
            continue;
        }
        int id,si;//输入的作业和大小
        if(choose==1)
        {
            printf("请输入作业号和作业内存大小:");
            scanf("%d %d",&id,&si);
            if(n-use_n < si)
            {
                printf("可用空间已不足");
                con();
                continue;
            }
            if(find_id(id))
            {
                printf("作业已存在\n");
                con();
                continue;
            }
            int flag=0;
            for(int i=1; i<=sum; i++)
            {
                if(a[i].id==-1 && (a[i].en-a[i].st+1)>=si)//当前空间为空并且大小合适
                {
                    flag=1;
                    if((a[i].en-a[i].st+1)>si)//如果空间还有剩余
                    {
                        next(i+1);//所有空间空后移一位
                        //此空间划分为两个空间，前面的存作业，后面的为空
                        a[i+1].st = a[i].st+si;
                        a[i+1].en = a[i].en;
                        a[i+1].id = -1;
                        sum++;
                    }
                    a[i].en = a[i].st+si-1;
                    a[i].id = id;
                    use_n+=si;
                    break;
                }
            }
            if(flag == 0)
            {
                printf("没有合适的空间存储作业\n");
                con();
                continue;
            }
            show();
            con();
        }
        else
        {
            huishou();
        }
    }
}
void worst_fit()
{
    while(1)
    {
        printf("当前为最坏适应算法:\n");
        printf("请选择操作项目：1、新到作业\t2、回收作业\t-1、退出:");
        int choose;
        scanf("%d",&choose);
        if(choose == -1)
            break;
        if(choose!=1&&choose!=2)
        {
            printf("输入错误请重新输入\n");
            con();
            continue;
        }
        int id,si;//输入的作业和大小
        if(choose == 1)
        {
            printf("请输入作业号和作业内存大小:");
            scanf("%d %d",&id,&si);
            if(n-use_n < si)
            {
                printf("可用空间已不足");
                con();
                continue;
            }
            if(find_id(id))
            {
                printf("作业已存在\n");
                con();
                continue;
            }
            int max_memery=-1;//最大的空闲区域
            int max_position=-1;//最大空闲区域的位置
            for(int i=1; i<=sum; i++)
            {
                int lme=a[i].en-a[i].st+1;
                if(lme>=si && a[i].id==-1)
                {
                    if(lme>max_memery)
                    {
                        max_memery = lme;
                        max_position=i;
                    }

                }
            }
            if(max_memery > si)
            {
                next(max_position+1);
                a[max_position+1].en = a[max_position].en;
                a[max_position+1].st = a[max_position].st+si;
                a[max_position+1].id = -1;
            }
            a[max_position].en = a[max_position].st+si-1;
            a[max_position].id = id;
            sum++;
            use_n += si;
            show();
            con();
        }
        else
        {
            huishou();
        }
    }
}
void best_fit()
{
    while(1)
    {
        printf("当前为最佳适应算法:\n");
        printf("请选择操作项目：1、新到作业\t2、回收作业\t-1、退出:");
        int choose;
        scanf("%d",&choose);
        if(choose == -1)
            break;
        if(choose!=1&&choose!=2)
        {
            printf("输入错误请重新输入\n");
            con();
            continue;
        }
        int id,si;//输入的作业和大小
        if(choose == 1)
        {
            printf("请输入作业号和作业内存大小:");
            scanf("%d %d",&id,&si);
            if(n-use_n < si)
            {
                printf("可用空间已不足");
                con();
                continue;
            }
            if(find_id(id))
            {
                printf("作业已存在\n");
                con();
                continue;
            }
            int min_memery=n+1;//最小的空闲区域
            int min_position=-1;//最小空闲区域的位置
            for(int i=1; i<=sum; i++)
            {
                int lme=a[i].en-a[i].st+1;
                if(lme>=si && a[i].id==-1)
                {
                    if(lme<min_memery)
                    {
                        min_memery = lme;
                        min_position=i;
                    }

                }
            }
            if(min_memery > si)
            {
                next(min_position+1);
                a[min_position+1].en = a[min_position].en;
                a[min_position+1].st = a[min_position].st+si;
                a[min_position+1].id = -1;
            }
            a[min_position].en = a[min_position].st+si-1;
            a[min_position].id = id;
            sum++;
            use_n += si;
            show();
            con();
        }
        else
        {
            huishou();
        }
    }
}
int main()
{


    int x;
    while(1)
    {
        printf("请输入最大空间内存（最大1000000）：");
        scanf("%d",&n);
        system("cls");

        /*************/
        while(1)
        {
            //初始化初始空间，全部为空
            a[1].st=1;
            a[1].en=n;
            a[1].id=-1;
            use_n=0;
            sum=1;
            printf("请选择要使用的算法\n");
            printf("1、首次适应算法\t2、最佳适应算法\t3、最坏适应算法\t-1、退出:");
            scanf("%d",&x);
            if(x==-1)
                break;
            switch(x)
            {
            case 1:
                First_memery();
                break;
            case 2:
                best_fit();
                break;
            case 3:
                worst_fit();
                break;
            default:
                printf("请输入1||2||3\n");
            }
            system("pause");
            system("cls");
        }
    }
    return 0;
}