精华内容
下载资源
问答
  • 最坏适应算法

    2012-01-06 09:59:57
    详细的操作系统动态分区的最坏适应算法代码,用C++语言实现的,简洁明了。
  • 主要介绍最先适应算法、下次适应算法、最优适应算法、最坏适应算法的定义和特点,无代码实现。

    思维图

    0

    一、最先(首次)适应算法(first fit,FF

    通俗来讲就是:把进程尽量往低地址空闲区域放,放不下的话在更加地址慢慢升高。
    每一次存放,都从最低地址开始寻找满足的空闲区域,直至最高地址。即每次存放都从0开始。

    特点

    • 算法优先使用 低地址 部分空闲区,在低址空间造成许多小的空闲区,在高地址空间保留大的空闲区。
    • 选取满足申请长度要求且起始地址最小的空闲区域。
    • 空闲区域按照 起始地址 从小到大 的次序以此记录在空闲区域表中。

    优点

    • 尽量使用低地址空间,使在高地址可能形成较大的空闲区域。为以后到达的大作业分配大的内存空间创造了条件。

    缺点

    • 可能会分隔位于低地址的较大空闲区域。
    • 低址部分不断被划分,会留下许多难以利用的,很小的空闲分区,称为碎片。

    二、下次适应算法(next fit,NF

    该算法是在FF算法的基础上进行改进的,大体上与FF算法相似,而不同点就是:
    FF算法每次存储都是从0开始寻找符合要求的空闲区域;
    NF算法每次存储都是接着上次分配区域的下一个地址;

    特点

    • 该算法是对FF算法的一种改进。
    • 自上次分配空闲空间区域的下一个位置开始,选取第一个可满足的空闲区域。

    优点

    • 空闲区域分布和分配更加均匀。

    缺点

    • 可能会分隔大的空闲区域,导致以后到达的大作业无较大的空闲区域。

    三、最佳适应算法(best fit,BF

    该算法和FF算法相似,每当进程申请空间的时候,系统都是从头部开始查找。
    空闲区域是从小到大记录的,每次查找都从最小的开始,直到查找的满足要求的最小空闲区域。

    特点

    • 在分配内存空间时取满足申请要求且长度最小的空闲区域。
    • 空闲区域按照长度“由小到大”的次序以此记录于空闲区域表中。

    优点

    • 尽量不分割大的空闲区域。

    缺点

    • 可能会形成许多非常小以致以后无法使用的的空闲空间,即外部碎片。

    四、最坏适应算法(worst fit,WF

    该算法与BF算法相反,BF是用最小的空闲区域来存储东西,而WF是用最大的空闲区域来存储。

    特点

    • 在分配空间时选取满足申请要求且长度“最大”的空闲区域。
    • 空闲区域按照长度“由大到小”的次序以此记录于空闲区域表中。

    优点

    • 避免形成外部碎片

    缺点

    • 会分隔大的空闲区域,可能当遇到较长存储空间的进程时无法满足其要求。

    例题

    下图中,最左边的是内存的初始情况,现在需要将4个进程依次放入输入井中,等待系统放入内存。
    JOB1 30K
    JOB2 50K
    JOB3 20K
    JOB4 60K
    红色:已经占用的空间。
    绿色:空闲空间。
    黄色:上述4个进程占用的空间。

    02

    资料参考

    展开全文
  • [c++]代码库#include#includeusing namespace std;#define Free 0 //空闲状态#define Busy 1 //已用状态#define OK 1 //完成#define ERROR 0 //出错#define MAX_length 640 //最大内存空间为640KBtypedef int Status...

    [c++]代码库#include

    #include

    using namespace std;

    #define Free 0 //空闲状态

    #define Busy 1 //已用状态

    #define OK 1 //完成

    #define ERROR 0 //出错

    #define MAX_length 640 //最大内存空间为640KB

    typedef int Status;

    int flag;

    typedef struct freearea//定义一个空闲区说明表结构

    {

    long size; //分区大小

    long address; //分区地址

    int state; //状态

    }ElemType;

    // 线性表的双向链表存储结构

    typedef struct DuLNode

    {

    ElemType data;

    struct DuLNode *prior; //前趋指针

    struct DuLNode *next; //后继指针

    }

    DuLNode,*DuLinkList;

    DuLinkList block_first; //头结点

    DuLinkList block_last; //尾结点

    Status alloc(int);//内存分配

    Status free(int); //内存回收

    Status First_fit(int);//首次适应算法

    Status Best_fit(int); //最佳适应算法

    Status Worst_fit(int); //最差适应算法

    void show();//查看分配

    Status Initblock();//开创空间表

    Status Initblock()//开创带头结点的内存空间链表

    {

    block_first=(DuLinkList)malloc(sizeof(DuLNode));

    block_last=(DuLinkList)malloc(sizeof(DuLNode));

    block_first->prior=NULL;

    block_first->next=block_last;

    block_last->prior=block_first;

    block_last->next=NULL;

    block_last->data.address=0;

    block_last->data.size=MAX_length;

    block_last->data.state=Free;

    return OK;

    }

    //分配主存

    Status alloc(int ch)

    {

    int request = 0;

    cout<

    cin>>request;

    if(request<0 ||request==0)

    {

    cout<

    return ERROR;

    }

    if(ch==2) //选择最佳适应算法

    {

    if(Best_fit(request)==OK) cout<

    else cout<

    return OK;

    }

    if(ch==3) //选择最差适应算法

    {

    if(Worst_fit(request)==OK) cout<

    else cout<

    return OK;

    }

    else //默认首次适应算法

    {

    if(First_fit(request)==OK) cout<

    else cout<

    return OK;

    }

    }

    //首次适应算法

    Status First_fit(int request)

    {

    //为申请作业开辟新空间且初始化

    DuLinkList temp=(DuLinkList)malloc(sizeof(DuLNode));

    temp->data.size=request;

    temp->data.state=Busy;

    DuLNode *p=block_first->next;

    while(p)

    {

    if(p->data.state==Free && p->data.size==request)

    {//有大小恰好合适的空闲块

    p->data.state=Busy;

    return OK;

    break;

    }

    if(p->data.state==Free && p->data.size>request)

    {//有空闲块能满足需求且有剩余

    temp->prior=p->prior;

    temp->next=p;

    temp->data.address=p->data.address;

    p->prior->next=temp;

    p->prior=temp;

    p->data.address=temp->data.address+temp->data.size;

    p->data.size-=request;

    return OK;

    break;

    }

    p=p->next;

    }

    return ERROR;

    }

    //最佳适应算法

    Status Best_fit(int request)

    {

    int ch; //记录最小剩余空间

    DuLinkList temp=(DuLinkList)malloc(sizeof(DuLNode));

    temp->data.size=request;

    temp->data.state=Busy;

    DuLNode *p=block_first->next;

    DuLNode *q=NULL; //记录最佳插入位置

    while(p) //初始化最小空间和最佳位置

    {

    if(p->data.state==Free && (p->data.size>=request) )

    {

    if(q==NULL)

    {

    q=p;

    ch=p->data.size-request;

    }

    else if(q->data.size > p->data.size)

    {

    q=p;

    ch=p->data.size-request;

    }

    }

    p=p->next;

    }

    if(q==NULL) return ERROR;//没有找到空闲块

    else if(q->data.size==request)

    {

    q->data.state=Busy;

    return OK;

    }

    else

    {

    temp->prior=q->prior;

    temp->next=q;

    temp->data.address=q->data.address;

    q->prior->next=temp;

    q->prior=temp;

    q->data.address+=request;

    q->data.size=ch;

    return OK;

    }

    return OK;

    }

    //最差适应算法

    Status Worst_fit(int request)

    {

    int ch; //记录最大剩余空间

    DuLinkList temp=(DuLinkList)malloc(sizeof(DuLNode));

    temp->data.size=request;

    temp->data.state=Busy;

    DuLNode *p=block_first->next;

    DuLNode *q=NULL; //记录最佳插入位置

    while(p) //初始化最大空间和最佳位置

    {

    if(p->data.state==Free && (p->data.size>=request) )

    {

    if(q==NULL)

    {

    q=p;

    ch=p->data.size-request;

    }

    else if(q->data.size < p->data.size)

    {

    q=p;

    ch=p->data.size-request;

    }

    }

    p=p->next;

    }

    if(q==NULL) return ERROR;//没有找到空闲块

    else if(q->data.size==request)

    {

    q->data.state=Busy;

    return OK;

    }

    else

    {

    temp->prior=q->prior;

    temp->next=q;

    temp->data.address=q->data.address;

    q->prior->next=temp;

    q->prior=temp;

    q->data.address+=request;

    q->data.size=ch;

    return OK;

    }

    return OK;

    }

    //主存回收

    Status free(int flag)

    {

    DuLNode *p=block_first;

    for(int i= 0; i <= flag; i++)

    if(p!=NULL)

    p=p->next;

    else

    return ERROR;

    p->data.state=Free;

    if(p->prior!=block_first && p->prior->data.state==Free)//与前面的空闲块相连

    {

    p->prior->data.size+=p->data.size;

    p->prior->next=p->next;

    p->next->prior=p->prior;

    p=p->prior;

    }

    if(p->next!=block_last && p->next->data.state==Free)//与后面的空闲块相连

    {

    p->data.size+=p->next->data.size;

    p->next->next->prior=p;

    p->next=p->next->next;

    }

    if(p->next==block_last && p->next->data.state==Free)//与最后的空闲块相连

    {

    p->data.size+=p->next->data.size;

    p->next=NULL;

    }

    return OK;

    }

    //显示主存分配情况

    void show()

    {

    int flag = 0;

    cout<

    cout<

    DuLNode *p=block_first->next;

    cout<

    while(p)

    {

    cout<

    cout<data.address<

    cout<data.size<

    if(p->data.state==Free) cout<

    else cout<

    p=p->next;

    }

    cout<

    }

    //主函数

    void main()

    {

    int ch;//算法选择标记

    cout<

    cout<

    cin>>ch;

    while(ch<1||ch>3)

    {

    cout<

    cin>>ch;

    }

    Initblock(); //开创空间表

    int choice; //操作选择标记

    while(1)

    {

    show();

    cout<

    cout<

    cin>>choice;

    if(choice==1) alloc(ch); // 分配内存

    else if(choice==2) // 内存回收

    {

    int flag;

    cout<

    cin>>flag;

    free(flag);

    }

    else if(choice==0) break; //退出

    else //输入操作有误

    {

    cout<

    continue;

    }

    }

    }

    694748ed64b9390909c0d88230893790.png

    展开全文
  • [c++]代码库#include#includeusing namespace std;#define Free 0 //空闲状态#define Busy 1 //已用状态#define OK 1 //完成#define ERROR 0 //出错#define MAX_length 640 //最大内存空间为640KBtypedef int Status...

    [c++]代码库#include

    #include

    using namespace std;

    #define Free 0 //空闲状态

    #define Busy 1 //已用状态

    #define OK 1 //完成

    #define ERROR 0 //出错

    #define MAX_length 640 //最大内存空间为640KB

    typedef int Status;

    int flag;

    typedef struct freearea//定义一个空闲区说明表结构

    {

    long size; //分区大小

    long address; //分区地址

    int state; //状态

    }ElemType;

    // 线性表的双向链表存储结构

    typedef struct DuLNode

    {

    ElemType data;

    struct DuLNode *prior; //前趋指针

    struct DuLNode *next; //后继指针

    }

    DuLNode,*DuLinkList;

    DuLinkList block_first; //头结点

    DuLinkList block_last; //尾结点

    Status alloc(int);//内存分配

    Status free(int); //内存回收

    Status First_fit(int);//首次适应算法

    Status Best_fit(int); //最佳适应算法

    Status Worst_fit(int); //最差适应算法

    void show();//查看分配

    Status Initblock();//开创空间表

    Status Initblock()//开创带头结点的内存空间链表

    {

    block_first=(DuLinkList)malloc(sizeof(DuLNode));

    block_last=(DuLinkList)malloc(sizeof(DuLNode));

    block_first->prior=NULL;

    block_first->next=block_last;

    block_last->prior=block_first;

    block_last->next=NULL;

    block_last->data.address=0;

    block_last->data.size=MAX_length;

    block_last->data.state=Free;

    return OK;

    }

    //分配主存

    Status alloc(int ch)

    {

    int request = 0;

    cout<

    cin>>request;

    if(request<0 ||request==0)

    {

    cout<

    return ERROR;

    }

    if(ch==2) //选择最佳适应算法

    {

    if(Best_fit(request)==OK) cout<

    else cout<

    return OK;

    }

    if(ch==3) //选择最差适应算法

    {

    if(Worst_fit(request)==OK) cout<

    else cout<

    return OK;

    }

    else //默认首次适应算法

    {

    if(First_fit(request)==OK) cout<

    else cout<

    return OK;

    }

    }

    //首次适应算法

    Status First_fit(int request)

    {

    //为申请作业开辟新空间且初始化

    DuLinkList temp=(DuLinkList)malloc(sizeof(DuLNode));

    temp->data.size=request;

    temp->data.state=Busy;

    DuLNode *p=block_first->next;

    while(p)

    {

    if(p->data.state==Free && p->data.size==request)

    {//有大小恰好合适的空闲块

    p->data.state=Busy;

    return OK;

    break;

    }

    if(p->data.state==Free && p->data.size>request)

    {//有空闲块能满足需求且有剩余

    temp->prior=p->prior;

    temp->next=p;

    temp->data.address=p->data.address;

    p->prior->next=temp;

    p->prior=temp;

    p->data.address=temp->data.address+temp->data.size;

    p->data.size-=request;

    return OK;

    break;

    }

    p=p->next;

    }

    return ERROR;

    }

    //最佳适应算法

    Status Best_fit(int request)

    {

    int ch; //记录最小剩余空间

    DuLinkList temp=(DuLinkList)malloc(sizeof(DuLNode));

    temp->data.size=request;

    temp->data.state=Busy;

    DuLNode *p=block_first->next;

    DuLNode *q=NULL; //记录最佳插入位置

    while(p) //初始化最小空间和最佳位置

    {

    if(p->data.state==Free && (p->data.size>=request) )

    {

    if(q==NULL)

    {

    q=p;

    ch=p->data.size-request;

    }

    else if(q->data.size > p->data.size)

    {

    q=p;

    ch=p->data.size-request;

    }

    }

    p=p->next;

    }

    if(q==NULL) return ERROR;//没有找到空闲块

    else if(q->data.size==request)

    {

    q->data.state=Busy;

    return OK;

    }

    else

    {

    temp->prior=q->prior;

    temp->next=q;

    temp->data.address=q->data.address;

    q->prior->next=temp;

    q->prior=temp;

    q->data.address+=request;

    q->data.size=ch;

    return OK;

    }

    return OK;

    }

    //最差适应算法

    Status Worst_fit(int request)

    {

    int ch; //记录最大剩余空间

    DuLinkList temp=(DuLinkList)malloc(sizeof(DuLNode));

    temp->data.size=request;

    temp->data.state=Busy;

    DuLNode *p=block_first->next;

    DuLNode *q=NULL; //记录最佳插入位置

    while(p) //初始化最大空间和最佳位置

    {

    if(p->data.state==Free && (p->data.size>=request) )

    {

    if(q==NULL)

    {

    q=p;

    ch=p->data.size-request;

    }

    else if(q->data.size < p->data.size)

    {

    q=p;

    ch=p->data.size-request;

    }

    }

    p=p->next;

    }

    if(q==NULL) return ERROR;//没有找到空闲块

    else if(q->data.size==request)

    {

    q->data.state=Busy;

    return OK;

    }

    else

    {

    temp->prior=q->prior;

    temp->next=q;

    temp->data.address=q->data.address;

    q->prior->next=temp;

    q->prior=temp;

    q->data.address+=request;

    q->data.size=ch;

    return OK;

    }

    return OK;

    }

    //主存回收

    Status free(int flag)

    {

    DuLNode *p=block_first;

    for(int i= 0; i <= flag; i++)

    if(p!=NULL)

    p=p->next;

    else

    return ERROR;

    p->data.state=Free;

    if(p->prior!=block_first && p->prior->data.state==Free)//与前面的空闲块相连

    {

    p->prior->data.size+=p->data.size;

    p->prior->next=p->next;

    p->next->prior=p->prior;

    p=p->prior;

    }

    if(p->next!=block_last && p->next->data.state==Free)//与后面的空闲块相连

    {

    p->data.size+=p->next->data.size;

    p->next->next->prior=p;

    p->next=p->next->next;

    }

    if(p->next==block_last && p->next->data.state==Free)//与最后的空闲块相连

    {

    p->data.size+=p->next->data.size;

    p->next=NULL;

    }

    return OK;

    }

    //显示主存分配情况

    void show()

    {

    int flag = 0;

    cout<

    cout<

    DuLNode *p=block_first->next;

    cout<

    while(p)

    {

    cout<

    cout<data.address<

    cout<data.size<

    if(p->data.state==Free) cout<

    else cout<

    p=p->next;

    }

    cout<

    }

    //主函数

    void main()

    {

    int ch;//算法选择标记

    cout<

    cout<

    cin>>ch;

    while(ch<1||ch>3)

    {

    cout<

    cin>>ch;

    }

    Initblock(); //开创空间表

    int choice; //操作选择标记

    while(1)

    {

    show();

    cout<

    cout<

    cin>>choice;

    if(choice==1) alloc(ch); // 分配内存

    else if(choice==2) // 内存回收

    {

    int flag;

    cout<

    cin>>flag;

    free(flag);

    }

    else if(choice==0) break; //退出

    else //输入操作有误

    {

    cout<

    continue;

    }

    }

    }

    694748ed64b9390909c0d88230893790.png

    展开全文
  • 操作系统-最坏适应算法

    千次阅读 2017-11-27 20:37:22
    最坏适应算法也可初始化俩张表,一张表是进程分配表,一张是空闲区按从小到大的排序表,每次分配的时候只需判断空闲区的尾指针是否满足要求,满足则分配,不满足则输出内存不够请等待 代码 #include #include #...

    最坏适应算法也可初始化俩张表,一张表是进程分配表,一张是空闲区按从小到大的排序表,每次分配的时候只需判断空闲区的尾指针是否满足要求,满足则分配,不满足则输出内存不够请等待

    代码

    #include<iostream>
    #include<stdlib.h>
    #include<stdio.h>
    #define Free 0 //空闲状态
    #define Busy 1 //已用状态
    #define OK 1    //完成
    #define ERROR 0 //出错
    typedef int Status;
    int flag;
    /**
     *设置空闲块
     *有三个标识符
     *address起始地址
     *size空闲块大小
     *state空闲块状态
     */
    typedef struct freearea
    {
        int address;//空闲区地址
        int size;//作业空间大小
        int state;//空闲去状态
    } ElemType;
    /**
     *定义俩张表分别用于存放内存分配表和空闲表
     *内存分配表为*DuLinkList2,空闲表为*DuLinkList1
     */
    typedef struct DuLNode
    {
        ElemType data;
        struct DuLNode *prior;
        struct DuLNode *next;
    } DuLNode, *DuLinkList1,*DuLinkList2;
    /**
     *block_first
     *链表首地址
     *block_last
     *链表尾地址
     */
    DuLinkList1 block_first1;
    DuLinkList1 block_last1;
    DuLinkList2 block_first2;
    DuLinkList2 block_last2;
    void alloc(int);
    void free(int);
    Status worst(int);
    void show();
    /**
     *进程分配表DuLinkList2的初始化
     */
    void initblock()
    {
        block_first2=(DuLinkList2)malloc(sizeof(DuLNode));
        block_last2=(DuLinkList2)malloc(sizeof(DuLNode));
        block_first2->prior=NULL;
        block_first2->next=block_last2;
        block_last2->prior=block_first2;
        block_last2->next=NULL;
    }
    /**
     *初始化空闲表DuLinkList1
     *传入用户需设置的内存大小MAX_length
     */
    void initblock(int MAX_length)
    {
        block_first1=(DuLinkList1)malloc(sizeof(DuLNode));
        block_last1=(DuLinkList1)malloc(sizeof(DuLNode));
        block_first1->prior=NULL;
        block_first1->next=block_last1;
        block_last1->prior=block_first1;
        block_last1->next=NULL;
        block_last1->data.address=0;
        block_last1->data.size=MAX_length;
        block_last1->data.state=Free;


    }
    /**
     *输入进程请求的空闲块大小
     *调用分配空闲块大小的算法best(response)
     */
    void alloc()
    {
        int request;//用户输入的请求
        printf("请您输入进程所需分配的空间大小:");
        scanf("%d",&request);
        if(request<0||request==0)
        {
            printf("输入错误,内存大小不能小于等于0 请重新输入");


        }
        else
        {
            if(worst(request)==OK)//判断最佳适应算法是否实现
            {
                printf("分配成功!");


            }
            else
            {
                printf("内存不足分配失败!");


            }
        }


    }
    /**
     *最坏适应算法
     *在空闲表中找最后一个空闲块分配
     *空闲表已经按从小到大的顺序排列
     */
    Status worst(int request)
    {
        DuLinkList2 temp = (DuLinkList2)malloc(sizeof(DuLNode));//为进程分配表新增的指针分配内存空间
        temp->data.size=request;//把新进程的空间及状态赋给新增的指针
        temp->data.state=Busy;
        DuLNode *p = block_last1;//p是为了查找符合新进程所需空闲区大小的遍历指针
        DuLNode *p1 = block_first2->next;//p1是为了将新增的指针插入到进程分配表中
        while(p)
        {
            if(request<(p->data.size))//在空闲区查找是否存在大于申请进程大小的空闲区
            {
                temp->prior=p1->prior;//找到则将新分配的进程信息插入到进程分配表的首地址
                temp->next=p1;
                temp->data.address=p->data.address;
                p1->prior->next=temp;
                p1->prior=temp;
                p->data.address=temp->data.address+temp->data.size;
                p->data.size-=request;
                return OK;
                break;


            }
            else if(request==(p->data.size))//查找是否有空闲区存在等于申请分配内存的进程大小
            {
                p->prior->next=p->next;//找到则将心分配的进程信息插入到进程分配表中
                temp->prior=p1->prior;
                temp->next=p1;
                temp->data.address=p->data.address;
                p1->prior->next=temp;
                p1->prior=temp;
                return OK;
                break;
            }
            else//前面俩种情况都没找到则直接输出内存不够
            {
               return ERROR;
            }
        }
    }
    /**
     *回收内存算法
     *将要回收的进程块的大小与空闲表的数据依次进行比较
     *若小于则插到前面
     *若比尾指针大则直接放到尾指针后
     */
    void free(int flag)
    {
        DuLinkList1 temp = (DuLinkList2)malloc(sizeof(DuLNode));//回收分配表中的进程时需要在空闲表中新增一个指针
        DuLNode *p = block_first2;//为了遍历寻找用户输入的将回收的进程
        DuLNode *q = block_first1->next;//为了寻找大于等于插入的指针大小的指针
        for(int i=0; i<=flag; i++)
        {
            if(p!=NULL)
            {
                p=p->next;
            }
        }//找到了用户需要的回收的进程
        temp->data.address=p->data.address;
        temp->data.size=p->data.size;
        temp->data.state=Free;
        if(p!=block_first2&&p!=block_last2)
        {
               p->prior->next=p->next;//删除进程表中被回收的进程
        }
        else if(p==block_last2)
        {
            p->prior->next=NULL;
        }


        while(q)
        {
            if(q->data.size>=temp->data.size)//如果第一块空闲区的大小小于等于回收的进程空间大小则将回收的进程空间放到首地址
            {
                temp->prior=q->prior;
                q->prior->next=temp;
                temp->next=q;
                q->prior=temp;
                break;
            }
            else if(q!=block_last1&&q->data.size<temp->data.size)//如果第一块空闲区的大小大于回收的进程空间且该空闲块不是尾指针则遍历下一个
            {
                q=q->next;
            }
            //have a question
            else if(q==block_last1&&q->data.size<temp->data.size)//如果第一块空闲区的大小大于回收的进程空间且该空闲块是尾指针则将回收的进程空间插入到尾指针之后
            {
                temp->prior=block_last1;
                block_last1->next=temp;
                temp->next=NULL;
                break;
            }
        }
    }
    /**
     *显示空闲表分配函数
     *从链表的首指针开始
     *依次显示
     */
    void show1()
    {
        int flag=0;
        printf("主存分配情况:\n");
        DuLNode *q=block_first1->next;
        printf("分区号\t起始地址 分区大小\t状态\n\n");
        while(q)
        {
            printf("%d\t",flag);
            flag++;
            printf("%d\t",q->data.address);
            printf("%dKB\t",q->data.size);
            if(q->data.state==Free)
            {
                printf("      空闲\n\n");
            }
            else
            {
                printf("      已分配\n\n");
            }
            q=q->next;
        }
        printf("++++++++++++++++++++++++++++\n");
    }
    /**
     *显示进程分配表函数
     *从链表的首指针开始
     *依次显示
     */
    void show2()
    {
        int flag=0;
        printf("主存分配情况:\n");
        DuLNode *q=block_first2->next;
        printf("分区号\t起始地址 分区大小\t状态\n\n");
        while(q&&q!=block_last2)
        {
            printf("%d\t",flag);
            flag++;
            printf("%d\t",q->data.address);
            printf("%dKB\t",q->data.size);
            if(q->data.state==Free)
            {
                printf("      空闲\n\n");
            }
            else
            {
                printf("      已分配\n\n");
            }
            q=q->next;
        }
        printf("++++++++++++++++++++++++++++\n");
    }
    int main()
    {
        int c=1;
        int MAX_length;
        printf("**********您现在操作的是最坏适应分配算法*****************\n");
        printf("***请输入初始空闲片的大小:");
        scanf("%d",&MAX_length);
        initblock(MAX_length);
        initblock();
        int choice;
        while(c==1)
        {
            printf("\n1: 分配内存   2:回收内存  3:退出系统  4:显示进程运行情况 5:显示空闲区的情况\n");
            printf("*******请输入您将进行的操作:");
            scanf("%d",&choice);
            if(choice==1)
            {
                alloc();
                c=1;
            }
            else if(choice==2)
            {
                printf("请输入您想要回收的空闲块区号:");
                scanf("%d",&flag);
                free(flag);
                c=1;
            }
            else if(choice==3)
            {
                exit(1);
            }
            else if(choice==4)
            {
                show2();
                c=1;
            }
            else if(choice==5)
            {
                show1();
                c=1;
            }
            else
            {
                printf("操作不存在 请重新输入!");
                c=1;
            }
        }
        return 0;
    }

    展开全文
  • 在这里插入图片描述前言本文总结了常用的查找算法,内容包括:查找算法的定义和思路,动画演示查找算法代码实现:Python和Java查找算法性能分析:时间空间复杂度分析不同排序算法最佳使用场景面试知识点复习手册此...
  • 一个不太恰当的理解, 兵法如果将写好运行的程序比作战场, 码农就是指挥这场战斗的指挥官, 手中的代码就是被指挥的士兵和武器. 兵法就是取得这场战斗的胜利的关键所在. 运筹帷幄之中, 决胜于千里之外.我们的数据结构...
  • 4.最坏适应算法(worst fit,WF) 流程图: 代码实现:内存分配算法代码实现 1.首次适应算法(first Fit,FF) FF算法是以空闲链的首地址递增顺序组织起来,当提出分配需求时,遍历组织好的空白链,找到第...
  • 代码主体非本人原创,由于测试中发现问题经本人修改后上传。...该资源VS2010下可直接使用。优化了原代码中当出现请求内存块大小大于现有内存块大小时...可实现首次适应算法,循环首次适应算法,最佳适应算法,最坏适应算法
  • 最近有网友问能不能写一下LMS滤波算法的FPGA实现,当然可以,因为去年我就已经做过LMS滤波算法的FPGA实现,只是一直...本文所用的FPGA代码为去年写,记忆可能有些偏差,实现方法可能也有不妥之处,可供学习使用。其...
  • 三种内存分配算法总结及代码实现

    千次阅读 2018-05-16 19:24:23
    最坏适应算法 最佳适应算法 代码实现 首次适应算法 找第一个满足大小的空闲分区 该算法从空闲分区链首开始查找,直至找到一个能满足其大小要求的空闲分区为止。然后再按 照作业的大小,从该分区中划出一...
  • 操作系统最坏适应算法代码及其生成界面。
  • 最坏适应分配算法要扫描整个空闲分区或链表,总是挑选一个最大的空闲分区分割给作业使用。该算法要求将所有的空闲分区按其容量从大到小的顺序形成一空闲分区链,查找时只要看第一个分区能否满足作业要求。
  • 动态分区分配算法的模拟四类算法首次适应算法(FF)循环首次适应算法(NF)最佳适应算法(BF)最坏适应算法(WF)四类算法流程图首次适应算法(FF)循环首次适应算法(NF)最佳适应算法(BF)最坏适应算法(WF)源代码代码Partiton...
  • 动态内存分配算法实验报告包括:实验题目,实验目的,实验要求,实验内容,实验结果,实验总结及后附有详细源...3,采用最坏适应算法完成内存空间的分配 4,采用最佳适应算法完成内存空间的分配 5,实现内存回收功能
  • 设计程序模拟四种动态分区分配算法:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。假设内存中空闲分区个数为n,空闲分区大小分别为P1, … ,Pn,在动态分区分配过程中需要分配的进程个数...
  • 操作系统原理课程设计:可变式分区存储管理系统 采用空闲区链实现主存的分配与回收 使用首次适应算法、最优适应算法、最坏适应算法、最后适应算法
  • FF BF WF 算法 (java)

    2019-12-24 16:53:26
    1. 首次适应 FF • 每次从 低地址 开始查找 2.... 最坏适应 WF • 空闲分区 按 容量递减 链接 • 从大的分区开始查找 运行结果 -------java代码------------- package o...
  • 1 基于遗传算法的TSP算法(王辉) TSP (旅行商问题—Traveling Salesman Problem),是典型的NP完全问题,即其最坏情况下的时间复杂性随着问题规模的增大按指数方式增长,到目前为止不能找到一个多项式时间的有效算法...
  • 操作系统课程设计

    2014-03-19 11:57:15
    操作系统课程设计,java源代码,最佳适应算法和最坏适应算法
  • FCFS HRN SJF 多级反馈队列 时间片轮转 首次适应算法 最高优先数 最坏适应算法 最佳适应算法 九个算法的代码及可执行文件,包括实验报告
  • 原理可变分区调度算法最先适应算法(first fit algorithm)最佳适应算法(best fit algorithm)最坏适应算法(worst fit algorithm)思路步骤内存分配内存回收分区管理的主要优缺点1. 优点2. 缺点Pt2. 源码实现 Pt1....
  • 操作系统课程设计我的过渡为模拟设计段式存储管理的分配与回收(最坏适应算法)OperateSeg文件夹完整代码,同vs2017项目。先都写了(其实代码都差不多),还实现了紧缩和动态页式管理消除算法(LRU的近似算法,最近...
  • 报告及代码下载 1. 问题描述 1.1 动态分区式存贮区管理 (1) 首次适应算法 ...最坏适应算法是将输入的作业放置到主存中与它所需大小差距最大的空闲区中,尽可能地利用存储器中大的空闲区。 1.2 题目要求

空空如也

空空如也

1 2 3 4 5 6
收藏数 101
精华内容 40
关键字:

最坏适应算法代码