1. 程式人生 > >動態分割槽分配-迴圈首次適應演算法+最佳適應演算法

動態分割槽分配-迴圈首次適應演算法+最佳適應演算法

(文章待更新)

(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
*/