关闭

动态分区分配-循环首次适应算法+最佳适应算法

标签: 操作系统算法
2321人阅读 评论(5) 收藏 举报
分类:
(文章待更新)

(1)采用空闲区表,并增加已分配区表{未分配区说明表、已分配区说明表(分区号、起始地址、长度、状态)}。分配算法采用最佳适应算法(内存空闲区按照尺寸大小从小到大的排列)和循环首次适应算法,实现内存的分配与回收。

#include<iostream>
#include<cmath>
#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
int pos,n,Size; ///查找位置,分区数量,最小分割大小
struct List
{
    int id;///空闲分区编号
    int sad;///空闲分区首地址
    int rom;///空间
    int state;///状态,0为空,1为未满,2为满;
} L[2000];
struct Task
{
    int id;
    int rom;
    int sad;
} T[2000];
bool cmp(List a,List b)
{
    return a.rom<b.rom;
}
void print()
{
    int i;
    printf("|---------------------------------------------------------------|\n");
    printf("|       分区号    分区始址    分区大小    分区状态       |\n");
    printf("|---------------------------------------------------------------|\n");
    for(i=1; i<=n; i++)
    {
        printf("|        %3d        %3d         %3d         %3d          |\n",
               L[i].id,L[i].sad,L[i].rom,L[i].state);
        printf("|---------------------------------------------------------------|\n");
    }

}
void recycle()
{
    printf("请输入要释放占用空间任务的序号:\n");
    int l;
    int f1=0,f2=0,f3=0;
    int p1,p2;
    cin>>l;
    for(int i=1; i<=n; i++)
    {
        if(T[l].sad==L[i].sad+L[i].rom)
        {
            f1=1;
            p1=i;
        }
        if(T[l].sad+T[l].rom==L[i].sad)
        {
            f2=1;
            p2=i;
        }
    }
    //cout<<f1<<" "<<f2<<endl;
    if(f1==1&&f2==0)
    {
        L[p1].rom=L[p1].rom+T[l].rom;
    }
    else if(f1==0&&f2==1)
    {
        L[p2].rom=L[p2].rom+T[l].rom;
        L[p2].sad=T[l].sad;
    }
    else if(f1==1&&f2==1)
    {
        L[p1].rom=L[p1].rom+T[l].rom+L[p2].rom;
        for(int j=p1+1; j<=n; j++)
            L[j].id--;
        n--;
    }
    else if(f1==0&&f2==0)
    {
        int temp;
        for(int j=1; j<=n; j++)
        {
            if(L[j].sad>T[l].sad+T[l].rom)///实际上大于T[l].sad就可以
            {
                temp=j;
            }
        }
        for(int j=temp; j<=n; j++)
            T[j].id++;
        n++;
        L[temp].id=temp;
        L[temp].rom=T[l].rom;
        L[temp].sad=T[l].sad;
        L[temp].state=0;
    }
    cout<<"内存回收完毕!"<<endl;
}
void NF()///循环首次适应算法
{
    cout<<"选择采用'循环首次适应算法'进行内存分配\n"<<endl;
    int tmp;
    pos=1;///开始从第一个分区查找
    while(1)
    {
        cout<<"      *******************************************"<<endl;
        cout<<"      1: 分配内存             2: 回收内存        "<<endl;
        cout<<endl;
        cout<<"      3: 查看空闲分区表       0: 退出       "<<endl;
        cout<<"      *******************************************"<<endl;
        cout<<"请输入您的操作 :";
        cin>>tmp;
        int k=0;
        if(tmp==1)
        {
            k++;
            printf("请输入第%d个作业占用空间大小:\n",k);
            cin>>T[k].rom;
            T[k].id=k;
            int num=0;
            for(int i=pos;; i++)
            {
                num++;
                if(num>n)
                {
                    printf("作业请求内存空间过大,空闲分区表不能满足要求,内存分配失败!\n");
                    break;
                }
                if(i>n)
                {
                    i=1;
                    continue;
                }
                if((L[i].state==0||L[i].state==1)&&L[i].rom>=T[i].rom)
                {
                    if(L[i].rom-T[k].rom>Size)
                    {
                        L[i].sad=L[i].sad+T[k].rom;
                        L[i].rom=L[i].rom-T[k].rom;
                        L[i].state=1;
                        T[k].sad=L[i].sad-T[k].rom;
                        printf("内存分配成功!\n作业申请空间为%d\n起始地址为%d\n",T[k].rom,T[k].sad);
                        break;
                    }
                    else
                    {
                        L[i].sad=L[i].sad+Size;
                        L[i].rom=L[i].rom-Size;
                        L[i].state=2;
                        T[k].sad=L[i].sad-Size;
                        printf("内存分配成功!\n作业申请空间为%d\n起始地址为%d\n",L[i].rom,T[k].sad);
                        break;
                    }
                }
                else if(L[i].state=0&&L[i].rom-T[k].rom==Size)
                {
                    L[i].state=2;
                    T[k].sad=L[i].sad;
                    printf("内存分配成功!\n作业申请空间为%d\n起始地址为%d\n",T[k].rom,T[k].sad);
                    break;
                }
            }
        }
        else if(tmp==2)
        {
            recycle();
        }
        else if(tmp==3)
            print();
        else if(tmp==0)
            return;
        else
        {
            printf("输入有误,请重新输入!\n");
            continue;
        }
    }
}
void BF()///最佳适应算法
{
    cout<<"选择采用'最佳适应算法'进行内存分配\n"<<endl;
    sort(L+1,L+n+1,cmp);
    int tmp;
    while(1)
    {
        cout<<"      *******************************************"<<endl;
        cout<<"      1: 分配内存             2: 回收内存        "<<endl;
        cout<<endl;
        cout<<"      3: 查看空闲分区表       0: 退出       "<<endl;
        cout<<"      *******************************************"<<endl;
        cout<<"请输入您的操作 :";
        cin>>tmp;
        int k=0;
        if(tmp==1)
        {
            k++;
            printf("请输入第%d个作业占用空间大小:\n",k);
            cin>>T[k].rom;
            T[k].id=k;
            int i;
            for(i=1; i<=n; i++)
            {
                if(i>n)
                {
                    i=1;
                    continue;
                }
                if((L[i].state==0||L[i].state==1)&&L[i].rom>=T[i].rom)
                {
                    if(L[i].rom-T[k].rom>Size)
                    {
                        L[i].sad=L[i].sad+T[k].rom;
                        L[i].rom=L[i].rom-T[k].rom;
                        L[i].state=1;
                        T[k].sad=L[i].sad-T[k].rom;
                        printf("内存分配成功!\n作业申请空间为%d\n起始地址为%d\n",T[k].rom,T[k].sad);
                        break;
                    }
                    else
                    {
                        L[i].sad=L[i].sad+Size;
                        L[i].rom=L[i].rom-Size;
                        L[i].state=2;
                        T[k].sad=L[i].sad-Size;
                        printf("内存分配成功!\n作业申请空间为%d\n起始地址为%d\n",L[i].rom,T[k].sad);
                        break;
                    }
                }
                else if(L[i].state=0&&L[i].rom-T[k].rom==Size)
                {
                    L[i].state=2;
                    T[k].sad=L[i].sad;
                    printf("内存分配成功!\n作业申请空间为%d\n起始地址为%d\n",T[k].rom,T[k].sad);
                    break;
                }
            }
            if(i>n)
            {
                printf("作业请求内存空间过大,空闲分区表不能满足要求,内存分配失败!\n");
                break;
            }
        }
        else if(tmp==2)
        {
            recycle();
            sort(L+1,L+n+1,cmp);
        }
        else if(tmp==3)
            print();
        else if(tmp==0)
            return;
        else
        {
            printf("输入有误,请重新输入!\n");
            continue;
        }
    }
}
void init()
{
loop1:
    pos=1;
    printf("请输入空闲分区表分区数量:\n");
    cin>>n;
    printf("请输入每个空闲分区的分区大小,分区始址\n");
    for(int i=1; i<=n; i++)
    {
        printf("请输入第%d个分区的信息:\n",i);
        cin>>L[i].rom>>L[i].sad;
        L[i].id=i;
        L[i].state=0;
    }
    printf("输入完毕,当前空闲分区表状态为:\n");
    print();
    printf("请输入不再切割的剩余空间的大小:\n");
    cin>>Size;
loop2:
    printf("选择内存分配的算法:1.循环首次适应算法  2.最佳适应算法  3.重新编辑空闲分区表  4.退出 \n");
    int tmp;
    cin>>tmp;
    if(tmp==1)NF();
    else if(tmp==2)BF();
    else if(tmp==3)
    {
        goto loop1;
    }
    else if(tmp==4) return;
    else
    {
        printf("输入有误,请重新输入!\n");
        goto loop2;
    }
}

int main()
{
    init();
    return 0;
}

/*
5
50 85
32 155
70 275
60 532
10 980
3
1
1
25
3
2
1
3
0
*/


1
1

猜你在找
【直播】机器学习&数据挖掘7周实训--韦玮
【套餐】系统集成项目管理工程师顺利通关--徐朋
【直播】3小时掌握Docker最佳实战-徐西宁
【套餐】机器学习系列套餐(算法+实战)--唐宇迪
【直播】计算机视觉原理及实战--屈教授
【套餐】微信订阅号+服务号Java版 v2.0--翟东平
【直播】机器学习之矩阵--黄博士
【套餐】微信订阅号+服务号Java版 v2.0--翟东平
【直播】机器学习之凸优化--马博士
【套餐】Javascript 设计模式实战--曾亮
查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:11939次
    • 积分:473
    • 等级:
    • 排名:千里之外
    • 原创:37篇
    • 转载:0篇
    • 译文:0篇
    • 评论:5条