精华内容
下载资源
问答
  • 首次适应算法java代码
    2021-03-06 23:09:27

    操作操作系统大作业题目:首次适应算法分配内存学 号: 1207300142 学生姓名: 张鲁云 班级:计科 121 首次适应算法分配内存 一、 问题描述在内存分配中,动态分区是根据......

    第三节:首次适应算法的分析2015.4.14_计算机软件及应用_IT/计算机_专业资料。UNIX V6源代码分析。malloc(),mfree(). Linux系统存储区数据结构 ......

    (int);//首次适应算法 Status Best_fit(int); //最...

    专业 计算机科学与技术 姓名 教师签字 成绩 实验报告 【实验名称】 首次适应算法和循环首次适应算法 【实验目的】 学会主存空间分配与回收的基本方法首次适应算法和......

    //PrintList(); }// end of GetFree void Assign(int size) /*最佳适应算法和首次适应算法空闲分区的分配*/ { LN *p,*t; p=L->next; t=L; while(......

    ⊙释放区下邻空闲区 ⊙释放区上邻空闲区 ⊙释放区与上下空闲区均相邻 ⊙释放区与上下空闲区均不相邻 e)程序流程图※空闲链的首次适应算法分配流程图开始 申请 ......

    首次适应算法实验报告记录 ——— 作者: ——— 日期: 2 操作操作系统大作业题目:首次适应算法分配内存学 号: 1207300142 学生姓名: 张鲁云 班级:计科 121 3 ......

    动态分区分配-首次适应算法 动态分区分配是根据进程的实际需要,动态的为之分配内存的空间。 首次适应算法,要求空闲分区链以地址递增的次序链接,在分配内存时,从链首......

    掌握进程可变内存管理的几种内存分配与回收算法; 3.掌握可变分区算法中空闲分区的合并方法;二.实验内容实现首次适应算法;三.实验程序 #include <> #include <> #......

    上次找到的下一个空 闲区地址该空闲区与作业关系 循环首次适应算法 大于 等于 小...

    开展预约双向转诊制度及服务流程 上次找到的下一个空 闲区地址该空闲区与作业关系 循环首次适应算法 大于 等于 小于 该区大于作业要求 该空闲获等于作业要 求 该......

    上次找到的下一个空 闲区地址 循环首次适应算法 该空闲区与作业关系 大于 等于 ...

    首次适应算法 内存分配_IT/计算机_专业资料。操作系统,关于内存分配的算法之一,首次适应算法、最坏适应算法、最佳适应算法,实验报告 ...

    实验名称: 实验四 采用首次适应算法实现动态分区分配过程的模拟实验要求: 用 C 语言编程,实现采用首次适应算法的动态分区分配过程。实验内容: (1)空闲分区通过空闲......

    掌握进程可变内存管理的几种内存分配与回收算法; 3.掌握可变分区算法中空闲分区的合并方法;二.实验内容实现首次适应算法;三.实验程序 #include <> #include <> #......

    ? 最佳适应算法检查数组的每一个空闲块,选择适合所需请求大小的最 小空闲块。 内存管理:使用coremap[] ? coremap[]按照map的起始地址排序。 ? 首次适应算法 ?...

    徒手心肺复苏术操作流程 上次找到的下一个空 闲区地址该空闲区与作业关系 循环首次适应算法 大于 等于 小于 该区大于作业要求 该空闲获等于作业要 求 该空闲获......

    第三节:首次适应算法的分析_工学_高等教育_教育专区。《UNIX源码剖析》存储器...

    循环首次适应算法的动态分区分配方式模拟 1.设计目的 了解动态分区分配中使用的数...

    最佳适应算法源程序代码 #include ...

    更多相关内容
  • 学习资料收集于网络仅供参考 上次找到的下一个空 闲区地址 循环首次适应算法 该空闲区与作业关系 大于 等于 小于 该空闲获等于作业要 该空闲获小于作业要 该区大于作业要求 求 求 取出空闲区一块空间 截取长度并修改...
  • 实验目的 学会主存空间分配与回收的基本方法首次适应算法和循环首次适应算法 实验原理 理解在连续分区动态的存储管理方式下如何实现贮存空间的分配与回收 采用可变式分区管理使用最佳适应算法实现主存空间的分配与...
  • 代码主体非本人原创,由于测试中发现问题经本人修改后上传。...该资源VS2010下可直接使用。优化了原代码中当出现请求内存块大小大于现有内存块大小时...可实现首次适应算法,循环首次适应算法,最佳适应算法,最坏适应算法
  • 在可变分区管理方式下,采用首次适应算法(最先适应算法)实现主存空间的分配和回收。操作系统课程设计,用C语言实现。在VC6.0上调试通过。
  • 使用C语言实现了操作系统可变分区分配算法,实现了首次。循环首次、最佳、最坏等算法,可以运行在Linux系统上,只是算法的模拟,没有调用Linux系统内核数据
  • 1 需求分析 1 需求分析 1本程序要求实现对内存的动态分配与回收的模拟同时在内存的分配 1本程序要求实现对内存的动态分配与回收的模拟同时在内存的分配 时还必须使用首次适应算法最后还要显示内存块分配和回收后空闲...
  • 课程设计报告 课程设计题目循环首次适应的动态分区分配算法模拟 专 业计算机科学与技术 班 级10204102 姓 名谱 学 号: 10204102 指导教师: 高小辉 2013年 1 目 录 一循环首次适应算法 3 1. 概述 3 2需求分析3 二实验...
  • 使用双向链表的数据结构,用C语言成功实现了可变分区存储管理中的循环首次适应法,实现了对内存区的分配和释放管理。并且考虑了很多分配和释放内存区时的错误,如分配时内存不足,释放越界,重复释放等问题,并给出...
  • 用c 语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free(),其中,空闲分区通过空闲分区链来管理;在进行内存分配时,系统优先使用空闲区低端的空间。。。。 假设初始状态下,可用...
  • 实现首次适应算法的内存分配函数alloc_mem(int len),其中的参数为所申请的内存空间的长度,函数返回值为所分配到的内存空间的起始地址,分配时优先将空闲区的低端部分分配出去,如果空闲区较大,则留下的高端部分仍...
  • 编写并调试一个可变式分区分配的存储管理方案。并模拟实现分区的分配和回收过程。 对分配算法首次适应算法。 写的很硬,参考下吧。
  • 操作系统实验四主存空间的分配与回收首次适应算法和循环首次适应算法
  • 操作系统实验,使用首次适应算法和最佳适应算法对作业进行分配内存和回收内存
  • 首次适应算法编程实现对操作系统内存动态分区分配,主要功能包括分配内存和回收内存。
  • 首次适应算法最佳适应算法
  • 分区分配 首次适应 最佳适应 bf ff java实现
  • 回溯算法的一些例题 精品文档 精品文档 收集于网络如有侵权请联系管理员删除 收集于网络如有侵权请联系管理员删除 精品文档 收集于网络如有侵权请联系管理员删除 回溯算法 搜索与回溯是计算机解题中常用的算法很多...
  • 首次适应和循环首次适应算法.doc
  • 分配算法 首次适应算法 最佳适应算法 循环首次适应算法 有流程图 源代码
  • 常用的放置策略:首次匹配(首次适应算法)最佳匹配(最佳适应算法)最坏匹配(最坏适应算法)一、首次适应算法(First Fit):该算法从空闲分区链首开始查找,直至找到一个能满足其大小要求的空闲分区为止。然后再按照作业...

    所谓动态分区分配 就是在处理作业的过程中,建立分区,依用户请求的大小分配分区。在分区回收的过程中会涉及一个空间利用效率相关的放置策略,即选择空闲区的策略。

    常用的放置策略:

    首次匹配(首次适应算法)

    最佳匹配(最佳适应算法)

    最坏匹配(最坏适应算法)

    一、首次适应算法(First Fit):该算法从空闲分区链首开始查找,直至找到一个能满足其大小要求的空闲分区为止。然后再按照作业的大小,从该分区中划出一块内存分配给请求者,余下的空闲分区仍留在空闲分区链    中。

    特点: 该算法倾向于使用内存中低地址部分的空闲区,在高地址部分的空闲区很少被利用,从而保留了高地址部分的大空闲区。显然为以后到达的大作业分配大的内存空间创造了条件。

    缺点:低地址部分不断被划分,留下许多难以利用、很小的空闲区,而每次查找又都从低地址部分开始,会增加查找的开销。

    二、最佳适应算法(Best Fit):该算法总是把既能满足要求,又是最小的空闲分区分配给作业。为了加速查找,该算法要求将所有的空闲区按其大小排序后,以递增顺序形成一个空白链。这样每次找到的第一个满足要求的空闲区,必然是最优的。孤立地看,该算法似乎是最优的,但事实上并不一定。因为每次分配后剩余的空间一定是最小的,在存储器中将留下许多难以利用的小空闲区。同时每次分配后必须重新排序,这也带来了一定的开销。

    特点:每次分配给文件的都是最合适该文件大小的分区。

    缺点:内存中留下许多难以利用的小的空闲区。

    三、最坏适应算法(Worst Fit):最坏适应算法是将输入的作业放置到主存中与它所需大小差距最大的空闲区中。空闲区大小由大到小排序。

    特点:尽可能地利用存储器中大的空闲区。

    缺点:绝大多数时候都会造成资源的严重浪费甚至是完全无法实现分配。

    而在实现过程中,首次适应算法与最佳适应算法的区别在于:

    首次适应算法中空闲区的排列顺序是按地址大小排列,小地址在前,大地址在后;而最佳适应算法中空闲区的队列排列是空闲区块的大小,小的在前,大的在后。

    我在实现时用了一个结构体来存储空闲区的信息,然后再用双链表来实现空闲区队列(我本来是准备用单链表的,但是在遇到需要将空闲区块前插到链表中时不太方便,然后就换成双链表结果了)。

    其次,空闲区合并问题有些许复杂,我一开始写了之后,运行发现出现上下两个都是空闲区时,程序并没有合并成功,而是只改变了空闲区块内的状态字,后来发现是条件的判断和退出出了问题。

    具体操作详见代码:

    #include using namespace std;

    const int Max_length=640;//最大内存

    int a, b;//a记录算法编号,b记录操作编号

    struct freearea//空闲区的结构体

    {

    int ID;//分区号

    int size;//分区大小

    int address;//分区地址

    bool flag;//使用状态,0为未占用,1为已占用

    };

    typedef struct DuNode//双向链表结点

    {

    freearea data;//数据域

    DuNode *prior;//指针域

    DuNode *next;

    }*DuLinkList;

    DuLinkList m_rid = new DuNode, m_last = new DuNode;//双向链表首尾指针

    void init()//空闲区队列初始化

    {

    m_rid->prior = NULL;

    m_rid->next = m_last;

    m_last->prior = m_rid;

    m_last->next = NULL;

    m_rid->data.size = 0;

    m_last->data.address = 0;

    m_last->data.size = Max_length;

    m_last->data.ID = 0;

    m_last->data.flag = 0;//!!!

    }

    void show()

    {

    DuNode *p = m_rid->next;//指向空闲区队列的首地址

    cout << "+++++++++++++++++++++++++++++++++++++++" << endl;

    while (p)

    {

    cout << "分区号: ";

    if (p->data.ID == 0)

    cout << "FREE" << endl;

    else

    cout << p->data.ID << endl;

    cout << "分区起始地址: " << p->data.address << endl;

    cout << "分区大小: " << p->data.size << endl;

    cout << "分区状态: ";

    if (p->data.flag)

    cout << "已被占用" << endl;

    else

    cout << "空闲" << endl;

    cout << "——————————————————" << endl;

    p = p->next;

    }

    }

    bool first_fit(int id,int m_size)//首次适应算法

    {

    DuNode *p = m_rid->next;//指向空闲区队列的首地址

    DuLinkList fa = new DuNode;//新建一个空闲区并赋值

    //memset(fa, 0, sizeof(DuNode));

    fa->data.ID = id;

    fa->data.size = m_size;

    fa->data.flag = 1;//表示被占用

    while (p)//在空闲区列表中从低地址向高地址查找

    {

    if (p->data.size >= m_size && !p->data.flag)//找到大于等于所需的内存的空闲区

    {

    if (p->data.size == m_size)//刚好空闲区大小与所需大小相等

    {

    p->data.ID = id;

    p->data.flag = 1;

    free(fa);//清空新创建的空闲区

    return true;

    }

    else if(p->data.size>m_size)//空闲区比所需内存大,则需要将多的内存作回收处理

    {

    fa->data.address = p->data.address;//将空闲区的前半部分分出去

    p->data.address += m_size;

    p->data.size -= m_size;

    p->prior->next = fa;

    fa->next = p;

    fa->prior = p->prior;

    p->prior = fa;

    return true;

    }

    }

    p = p->next;

    }

    free(fa);//查找分配失败

    return false;

    }

    bool best_fit(int id, int m_size)//最佳适应算法,其中需要查找最佳的存放位置

    {

    DuNode *p = m_rid->next;//指向空闲区队列的首地址

    DuNode *q = NULL;//存放最佳地址

    DuLinkList fa = new DuNode;//新建一个空闲区并赋值

    memset(fa, 0, sizeof(DuNode));

    fa->data.ID = id;

    fa->data.size = m_size;

    fa->data.flag = 1;//表示被占用

    int d = Max_length;//所需内存大小与空闲区大小之间的差值

    while (p)//循环查找最小的差值d并记录此时的地址值

    {

    if (p->data.size >= m_size && !p->data.flag)//找到大于等于所需的内存的空闲区

    {

    if (p->data.size - m_size < d)

    {

    q = p;

    d = q->data.size - m_size;

    }

    }

    p = p->next;

    }

    if (q == NULL)//查找分配失败

    return false;

    else

    {

    if (d == 0)//刚好找到与所需内存大小一样的空闲区

    {

    p->data.ID = id;

    p->data.flag = 1;

    free(fa);//清空新创建的空闲区

    return true;

    }

    else//空闲区比所需内存大,则需要将多的内存作回收处理

    {

    fa->data.address = q->data.address;//将空闲区的前半部分分出去

    q->data.address += m_size;

    q->data.size -= m_size;

    q->prior->next = fa;

    fa->next = q;

    q->prior = fa;

    fa->prior = q->prior;

    return true;

    }

    }

    }

    bool allocation()//分配资源

    {

    int id, m_size;//输入的作业号和内存块大小

    cout << "请输入作业编号(分区号)和申请的内存大小(KB):";

    cin >> id >> m_size;

    if (m_size <= 0)//申请的内存大小小于等于0,申请失败

    {

    cout << "申请的内存大小错误!请重新输入" << endl;

    return false;

    }

    if (a == 1)//首次适应算法

    {

    if (first_fit(id, m_size))

    {

    cout << "内存分配成功!" << endl;

    show();//显示内存分布

    }

    else

    cout << "内存不足,分配失败!" << endl;

    return true;

    }

    if (a == 2)//最佳适应算法

    {

    if (best_fit(id, m_size))

    {

    cout << "内存分配成功!" << endl;

    show();//显示内存分布

    }

    else

    cout << "内存不足,分配失败!" << endl;

    return true;

    }

    }

    void recycle()//回收内存

    {

    int id;

    cout << "请输入想要释放的作业号:";

    cin >> id;

    DuNode *p = m_rid->next;//指向空闲区队列的首地址

    DuNode *p1 = NULL;//辅助向量

    while (p)//查找需要释放的作业的地址并进行合并工作

    {

    if (p->data.ID == id)

    {

    p->data.ID = 0;

    p->data.flag = 0;

    if (!p->prior->data.flag)//与前一个空闲区相邻,则合并

    {

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

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

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

    }

    if (!p->next->data.flag)//与后一个空闲区相邻,则合并

    {

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

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

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

    }

    break;

    }

    p = p->next;

    }

    show();

    }

    void main()

    {

    cout << "******************动态分区分配模拟******************" << endl;

    cout << "**********1.首次适应算法 2.最佳适应算法**********" << endl;

    cout << "请输入要选择的分配算法:";

    cin >> a;

    init();//初始化内存块

    while (a != 1 && a != 2)

    {

    cout << "输入错误!请重新输入:" << endl;

    cin >> a;

    }

    while (1)

    {

    cout << "****************************************************" << endl;

    cout << "**********1.申请内存 2.释放内存 3.退出**********" << endl;

    cout << "请输入操作数:";

    cin >> b;

    switch (b)

    {

    case 1:

    allocation();

    break;

    case 2:

    recycle();

    break;

    case 3:

    default:

    cout << "动态分区分配算法结束,再会!" << endl;

    exit(1);

    break;

    }

    }

    }

    运行结果:

    测试数据为:

    初始状态可用内存空间为640KB,请求序列:

    作业1申请130

    作业2申请60

    作业3申请100

    作业2释放60

    作业4申请200

    作业3释放100

    作业1释放130

    作业5申请140

    作业6申请60

    作业7申请50

    作业6释放60

    首次适应算法:(测试结果只显示了部分)

    2bb017d188034d489d6408afd27ad48a.png

    efbfbc9fd9cfd79f73020daf3a49b605.png

    6ed936fdfaba62a930f70304b2281f75.png

    b5aa2cbb247daa1924ac581e47b044c3.png

    最佳适应算法:(部分测试数据)

    dc83353be2a4995943070c5d7dc4114a.png

    e73260d5c3ae2b2054556d3b106932ba.png

    展开全文
  • 循环首次适应首次适应算法流程图.doc
  • 操作系统 循环首次适应算法 首次适应算法 最佳适应算法 回收内存 分配内存设计一个可变式分区分配的存储管理方案。并模拟实现分区的分配和回收过程。 对分区的管理法可以是下面三种算法: 首次适应算法 循环首次...
  • 1.首次适应算法(FF):将所有空闲分区按照地址递增的次序链接,在申请内存分配时,从链首开始查找,将满足需求的第一个空闲分区分配给作业。 void FirstFit() { cout << "***********首次适应算法***********...

    动态分区分配是根据进程的实际需要,动态地址为之分配内存空间,在分配时按照一定的分配算法,从空闲分区表或空闲分区链中选出一分区分配给该作业

    • 1.首次适应算法(FF):将所有空闲分区按照地址递增的次序链接,在申请内存分配时,从链首开始查找,将满足需求的第一个空闲分区分配给作业。

    • 2.循环首次适应算法(NF):将所有空闲分区按照地址递增的次序链接,在申请内存分配时,总是从上次找到的空闲分区的下一个空闲分区开始查找,将满足需求的第一个空闲分区分配给作业

    • 3.最坏适应算法(WF):将所有的空闲分区按照从大到小的顺序形成空闲分区链,在申请内存分配时,总是把满足需求的、最大的空闲分区分配给作业。

    • 4.最佳适应算法(BF): 将所有空闲分区按照从小到大的顺序形成空闲分区链,在申请内存分配时,总是把满足需求的、最小的空闲分区分配给作业。

    源码

    #include <iostream>
    #include <fstream>
    #include <iomanip>
    using namespace std;
    
    #define MAXNUMBER 100
    static int PartitionNum;  //内存中空闲分区的个数
    static int ProcessNum; //需要分配的进程个数
    static int FreePartition[MAXNUMBER];  //空闲分区对应的内存
    static int ProcessNeed[MAXNUMBER];  //需要分配的进程大小
    
    static int LeftFreePartition[MAXNUMBER];
    static int LeftProcessNeed[MAXNUMBER];
    
    static char ProcessName[MAXNUMBER];
    static char NameProcessToPartition[MAXNUMBER][MAXNUMBER];
    
    typedef struct
    {
    	int partitionSize;
    	int id;
    }sortNeed;
    
    void readDataFunction();
    void input();
    void display();
    void FirstFit();
    void NextFit();
    void BestFit();
    void WorstFit();
    void selectAlgorithm(int chooceAlgorithm);
    void display();
    
    
    void readDataFunction()
    {
    	cout<<"请输入空闲分区数"<<endl;
    	cin >> PartitionNum;
    		cout << "请输入空闲分区大小" << endl;
    	for (int i = 0; i<PartitionNum; i++)
    	{
    		cin >> FreePartition[i];
    	}
    	cout<<"请输入进程个数"<<endl;
    	cin >> ProcessNum;
    		cout<<"请输入进程名称"<<endl;
    	for (int i = 0; i<ProcessNum; i++)
    	{
    		cin >> ProcessName[i];
    	}
    		cout<<"请输入进程需要分配大小"<<endl;
    	for (int i = 0; i<ProcessNum; i++)
    	{
    		cin >> ProcessNeed[i];
    	}
    }
    
    void input()
    {
    	int chooseAlgorithm = 5;
    	do
    	{
    	//readDataFunction();
    	cout << "请选择实现的算法:" << endl;
    	cout << "*****  1 - 首次适应算法     *****" << endl;
    	cout << "*****  2 - 循环首次适应算法 *****" << endl;
    	cout << "*****  3 - 最佳适应算法     *****" << endl;
    	cout << "*****  4 - 最坏适应算法     *****" << endl;
    	cout << "*****  0 - 结束             *****" << endl;
    		cout << "chooseAlgorithm = ";
    		cin >> chooseAlgorithm;
    		selectAlgorithm(chooseAlgorithm);
    	//display();
    	} while (chooseAlgorithm);
    }
    
    void initial()
    {
    	readDataFunction();   //读取原始数据
    	for (int i = 0; i<PartitionNum; i++)
    	{
    		LeftFreePartition[i] = FreePartition[i];
    		for (int j = 0; j<ProcessNum; j++)
    		{
    			NameProcessToPartition[i][j] = NULL;
    		}
    	}
    	for (int i = 0; i<ProcessNum; i++)
    	{
    		LeftProcessNeed[i] = ProcessNeed[i];
    	}
    }
    
    
    void FirstFit()
    {
    	cout << "***********首次适应算法***********" << endl;
    	initial();
    
    	int i, j;
    	for (i = 0; i<ProcessNum; i++)   //逐个遍历每个进程
    	{
    		for (j = 0; j<PartitionNum; j++)
    		{
    			if (LeftProcessNeed[i] <= LeftFreePartition[j] && LeftFreePartition != 0)  //当系统内存分区足够大的时候,即分配给进程资源
    			{
    				LeftFreePartition[j] -= LeftProcessNeed[i];   //扣除分配给进程的资源
    				LeftProcessNeed[i] = 0;  //当且仅当系统内存分区足够时才执行,即当前进程大小置0
    
    				NameProcessToPartition[i][j] = ProcessName[i];  //存储各个进程所在的分区位置
    
    				break;   //!!!很重要,一个进程分区完后,应该立即break,进行下一个进程的判断
    			}
    		}
    	}
    
    	display();
    
    }
    
    void NextFit()
    {
    	cout << "***********循环首次适应算法***********" << endl;
    	initial();
    	int i, nextPoint = 0;
    	bool isWhile;
    	for (i = 0; i<ProcessNum; i++)
    	{
    		isWhile = true;
    		while (isWhile)
    		{
    			if (LeftFreePartition[nextPoint] >= LeftProcessNeed[i])
    			{
    				LeftFreePartition[nextPoint] -= LeftProcessNeed[i];
    				LeftProcessNeed[i] = 0;
    				NameProcessToPartition[i][nextPoint] = ProcessName[i];
    				nextPoint++;
    				if (nextPoint > PartitionNum - 1)
    				{
    					nextPoint = 0;  //当j遍历到分区末尾的时候,返回首位置
    				}
    				isWhile = false;
    			}
    			else
    				nextPoint++;
    		}
    	}
    	display();
    }
    
    void BestFit()
    {
    	//思想:利用冒泡排序对分区大小进行排序,但不改变原分区的位置
    	//创建一个结构体,包括分区大小和所对应的id,排序过程中,每改变顺序一次,id随着改变
    	//关键:每次分配完一个进程的内存大小后,都要重新排序
    	cout << "***********最佳适应算法***********" << endl;
    	initial();
    	int i, j, temp, tempID;
    
    	sortNeed best[MAXNUMBER];
    	for (i = 0; i<PartitionNum; i++)
    	{
    		//初始化结构体
    		best[i].partitionSize = FreePartition[i];
    		best[i].id = i;
    	}
    
    	for (i = 0; i<ProcessNum; i++)
    	{
    		for (int s = PartitionNum - 1; s > 0; s--)   //冒泡排序(每次分配完一个进程后,都需要重新排序)
    		{
    			for (int t = 0; t < s; t++)
    			{
    				if (best[s].partitionSize < best[t].partitionSize)
    				{
    					temp = best[s].partitionSize;
    					best[s].partitionSize = best[t].partitionSize;
    					best[t].partitionSize = temp;
    
    					tempID = best[s].id;
    					best[s].id = best[t].id;
    					best[t].id = tempID;
    				}
    			}
    		}
    
    		for (j = 0; j<PartitionNum; j++)
    		{
    			if (LeftProcessNeed[i] <= best[j].partitionSize)
    			{
    				best[j].partitionSize -= LeftProcessNeed[i];
    				LeftProcessNeed[i] = 0;
    
    				NameProcessToPartition[i][best[j].id] = ProcessName[i];
    				break;
    			}
    		}
    		LeftFreePartition[best[j].id] = best[j].partitionSize;
    	}
    
    	display();
    }
    
    void WorstFit()
    {
    	cout << "***********最坏适应算法***********" << endl;
    	initial();
    	int i, j, s, t, tempSize, tempID;
    	sortNeed Worst[MAXNUMBER];
    
    	for (i = 0; i<PartitionNum; i++)
    	{
    		Worst[i].partitionSize = FreePartition[i];
    		Worst[i].id = i;
    	}
    
    	for (i = 0; i<ProcessNum; i++)
    	{
    		for (s = PartitionNum - 1; s>0; s--)
    		{
    			for (t = 0; t<s; t++)
    			{
    				if (Worst[s].partitionSize > Worst[t].partitionSize)
    				{
    					tempSize = Worst[s].partitionSize;
    					Worst[s].partitionSize = Worst[t].partitionSize;
    					Worst[t].partitionSize = tempSize;
    
    					tempID = Worst[s].id;
    					Worst[s].id = Worst[t].id;
    					Worst[t].id = tempID;
    				}
    			}
    		}
    
    		for (j = 0; j<PartitionNum; j++)
    		{
    			if (LeftProcessNeed[i] <= Worst[j].partitionSize)
    			{
    				Worst[j].partitionSize -= LeftProcessNeed[i];
    				LeftProcessNeed[j] = 0;
    
    				NameProcessToPartition[i][Worst[j].id] = ProcessName[i];
    				break;
    			}
    		}
    		LeftFreePartition[Worst[j].id] = Worst[j].partitionSize;
    	}
    
    	display();
    
    }
    
    void selectAlgorithm(int chooseAlgorithm)
    {
    	switch (chooseAlgorithm)
    	{
    	case 0:break;
    	case 1:FirstFit(); break;
    	case 2:NextFit(); break;
    	case 3:BestFit(); break;
    	case 4:WorstFit(); break;
    	default:cout << "请输入正确的序号:" << endl;
    	}
    }
    
    void display()
    {
    	int i;
    	cout << "需要分配内存的进程名:" << setw(10);
    	for (i = 0; i<ProcessNum; i++)
    	{
    		cout << ProcessName[i] << setw(6);
    	}
    	cout << endl;
    	cout << "需要分配内存的进程分区大小:" << setw(4);
    	for (i = 0; i<ProcessNum; i++)
    	{
    		cout << ProcessNeed[i] << setw(6);
    	}
    	cout << endl;
    	cout << "分配结果:" << endl;
    
    	cout << "分区序号:";
    	for (i = 0; i<PartitionNum; i++)
    	{
    		cout << "分区" << i + 1 << " ";
    	}
    	cout << endl << "分区大小:";
    	for (i = 0; i<PartitionNum; i++)
    	{
    		cout << FreePartition[i] << "     ";
    	}
    	cout << endl << "剩余大小: ";
    	for (i = 0; i<PartitionNum; i++)
    	{
    		cout << LeftFreePartition[i] << "     ";
    	}
    	cout << endl << "分配进程情况:" << endl;
    	for (i = 0; i<PartitionNum; i++)
    	{
    		for (int j = 0; j<ProcessNum; j++)
    		{
    			if (NameProcessToPartition[j][i] != NULL)
    			{
    				cout << NameProcessToPartition[j][i] << ": (分区" << i + 1 << ")" << endl;
    			}
    		}
    		//cout<<"  ";
    	}
    	cout << endl << "********结束**********" << endl;
    }
    
    int main()
    {
    	input();
    	return 0;
    }
    
    展开全文
  • 课程设计题目为用首次适应算法模拟内存的分配和回收,适用于东秦学子们
  • 存储管理实验(3个) 首次适应算法,循环首次适应算法,最佳适应算法
  • 基于顺序搜索的动态分区分配算法有如下四种:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法,下面分别进行介绍。 1.首次适应(first fit, FF)算法 我们以空闲分区链为例来说明采用FF算法时的分配情况。...

    算法介绍

    一、动态分区分配算法
    为把一个新作业装入内存,须按照一定的分配算法, 从空闲分区表或空闲分区链中出一分区分配给该作业。由于内存分配算法对系统性能有很大的影响,故人们对它进行了较为广泛而深入的研究,于是产生了许多动态分区分配算法。传统的四种分配算法,它们都属于顺序式搜索算法。
    二、分区分配操作
    在动态分区存储管理方式中,主要的操作是分配内存和回收内存。
    1)分配内存
    系统应利用某种分配算法,从空闲分区链(表)中找到所需大小的分区。设请求的分区大小为u.size,表中每个空闲分区的大小可表示为m.size. 若m.size-u.size≤size(size是事先规定的不再切割的剩余分区的大小),说明多余部分太小,可不再切割,将整个分区分配给请求者。否则(即多余部分超过size),便从该分区中按请求的大小划分出一块内 存空间分配出去,余下的部分仍留在空闲分区链(表)中。然后,将分配区的首址返回给调用者。图示出了分配流程。
    在这里插入图片描述
    2)回收内存
    当进程运行完毕释放内存时,系统根据回收区的首址,从空闲区链(表)中找到相应的插入点,此时可能出现以下四种情况之一:
    (1)回收区与插入点的前一个空闲分区F1 相邻接, 此时应将回收区与插入点的前一分区合并,不必为回收分区分配新表项,而只需修改其前一分区F的大小。如图(a)。
    (2)回收分区与插入点的后一空闲分区F2相邻接,此时也可将两分区合并,形成新的空闲分区,但用回收区的首址作为新空闲区的首址,大小为两者之和。如图(b)
    (3)回收区同时与插入点的前、后两个分区邻接。此时将三个分区合并,使用F的表项和F的首址,取消F2的表项,大小为三者之和。如图(c)。
    (4)回收区既不与F邻接,又不与F2邻接。这时应为回收区单独建立一个新表项,填写回收区的首址和大小,并根据其首址插入到空闲链中的适当位置。

    在这里插入图片描述
    内存回收时流程图:
    在这里插入图片描述
    三、基于顺序搜索的动态分区分配算法

    为了实现动态分区分配,通常是将系统中的空闲分区链接成一个链。所谓顺序搜索,是指依次搜索空闲分区链上的空闲分区,去寻找一个其大小能满足要求的分区。基于顺序搜索的动态分区分配算法有如下四种:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法,下面分别进行介绍。

    1.首次适应(first fit, FF)算法

    我们以空闲分区链为例来说明采用FF算法时的分配情况。FF算法要求空闲分区链以地址递增的次序链接。在分配内存时,从链首开始顺序查找,直至找到一个大小能满足要求的空闲分区为止。然后再按照作业的大小,从该分区中划出一块内存空间,分配给请求者,余下的空闲分区仍留在空闲链中。若从链首直至链尾都不能找到一个能满足要求的分区,则表明系统中已没有足够大的内存分配给该进程,内存分配失败,返回。该算法倾向于优先利用内存中低址部分的空闲分区,从而保留了高址部分的大空闲区。这为以后到达的大作业分配大的内存空间创造了条件。其缺点是低址部分不断被划分,会
    留下许多难以利用的、很小的空闲分区,称为碎片。而每次查找又都是从低址部分开始的,这无疑又会增加查找可用空闲分区时的开销。

    2.循环首次适应(next fit,NF)算法

    为避免低址部分留下许多很小的空闲分区,以及减少查找可用空闲分区的开销,循环首次适应算法在为进程分配内存空间时,不再是每次都从链首开始查找,而是从上次找到的空闲分区的下一个空闲分区开始查找,直至找到一一个能满足要求的空闲分区,从中划出一块 与请求大小相等的内存空间分配给作业。为实现该算法,应设置一起始查寻指针,用于指示下一次起始查寻的空闲分区,并采用循环查找方式,即如果最后一个(链尾)空闲分区的大小仍不能满足要求,则应返回到第一个空闲分区,比较其大小是否满足要求。找到后,应调整起始查寻指针。该算法能使内存中的空闲分区分布得更均匀,从而减少了查找空闲分区时的开销,但这样会缺乏大的空闲分区。

    3.最佳适应(best fit,BF)算法

    所谓“最佳”是指,每次为作业分配内存时,总是把能满足要求、又是最小的空闲分区分配给作业,避免“大材小用”。为了加速寻找,该算法要求将所有的空闲分区按其容量以从小到大的顺序形成——空闲分区链。这样,第一次找到的能满足要求的空闲区必然是最佳的。孤立地看,最佳适应算法似乎是最佳的,然而在宏观上却不一定。 因为每次分配后所切割下来的剩余部分总是最小的,这样,在存储器中会留下许多难以利用的碎片。

    4.最坏适应(worst fit, WF)算法

    由于最坏适应分配算法选择空闲分区的策略正好与最佳适应算法相反:它在扫描整个空闲分区表或链表时,总是挑选-一个最大的空闲区,从中分割一部分存储空间给作业使用,以至于存储器中缺乏大的空闲分区,故把它称为是最坏适应算法。实际上,这样的算法未必是最坏的,它的优点是可使剩下的空闲区不至于太小,产生碎片的可能性最小,对中、小作业有利。同时,最坏适应分配算法查找效率很高,该算法要求,将所有的空闲分区,按其容量以从大到小的顺序形成——空闲分区链,查找时,只要看第一个分区能否满足作业要求即可。

    直接代码(实验原因封装在一块)

    .h文件(头文件)

    #pragma once
    #include<iostream>
    using namespace std;
    
    typedef struct Node
    {
    	int pid;//分区号
    	long size;//分区大小
    	long start_locat;//分区起始地址
    	int status;//分区状态
    	struct Node* next;
    	struct Node* perior;
    }Node, *PNode;
    void Init_list(PNode list);//初始化头结点
    void Creat_list(PNode list);//初始化链表
    PNode Insert_Node();//新插入链表
    long* _Sort_min(long* p);//小到大因为实验量小采用冒泡排序
    long* _Sort_max(long* p);//大到小因为实验量小采用冒泡排序
    void First_fit(PNode list);//FF首次适应算法
    void Next_fit(PNode list);//循环首次适应
    void Best_fit(PNode list);//BF 最佳适应算法
    void Worst_fit(PNode list);//最欢适应算法
    void Release_Mem(PNode list);//回收内存
    void Show(PNode list);
    

    .cpp文件

    #include<assert.h>
    #include"list.h"
    
    #define MAX_ALLOC_SIZE 600000
    long start_add, end_add, memory_size;// 起始地址,终止地址,内存大小 
    int free_num = 0;
    Node* Flag_Node = NULL;
    void Init_list(PNode list)
    {
    	assert(NULL != list);
    	list->next =list;
    	list->perior = list;
    	list->start_locat = start_add;
    	list->size = 0;
    	list->status = 1;
    }
    void Creat_list(PNode list)
    {
    	assert(NULL != list);
    	int _id = -1, _num = 0;
    	long _size = -1;
    	long _locat = list->start_locat;
    	cout << "请输入申请资源的进程个数:" << endl;
    	cin >> _num;
    	for (int i = 0; i <= _num; i++)
    	{
    		Node* newnode = (Node*)malloc(sizeof(Node));
    		assert(NULL != newnode);
    		if (i < _num)
    		{
               cout << "请输入第" << i + 1 << "个进程调入的分区号及其大小:" << endl;
    		   cin >> _id >> _size;
    		   newnode->pid = _id;
    		   newnode->size = _size;
    		   newnode->start_locat = _locat;
    		   newnode->status = 1;
    		   _locat += _size;
    		}
    		else
    		{
    			newnode->pid = -1;
    			newnode->size = memory_size - _locat;
    			newnode->start_locat = _locat;
    			newnode->status = 0;
    			free_num++;
    		}
    		PNode ptr = list;
    		for (ptr; ptr->next != list; ptr = ptr->next);
    		newnode->next = list;
    		newnode->perior = ptr;
    		ptr->next = newnode;
    		list->perior = newnode;
    	}
    }
    PNode Insert_Node()
    {
    	Node* newnode = (Node*)malloc(sizeof(Node));
    	assert(NULL != newnode);
    	int _id = 0;
    	long _size = 0;
    	cout << "请输入进程调入的分区号及其大小:" << endl;
    	cin >> _id >> _size;
    	newnode->next = NULL;
    	newnode->perior = NULL;
    	newnode->pid = _id;
    	newnode->size = _size;
    	newnode->start_locat = 0;
    	newnode->status = 0;
    	return newnode;
    
    }
    void First_fit(PNode list)
    {
    	assert(NULL != list);
    	PNode _head = Insert_Node();
    	PNode ptr = list;
    	while (ptr->next != list)
    	{
    		PNode cur = ptr->next;
    		if (cur->status==0&&cur->size > _head->size)
    		{ 
    			_head->next = cur;
    			_head->perior = ptr;
                 cur->perior = _head;
    			 ptr->next = _head;
    			_head->status = 1;
    			_head->start_locat = ptr->start_locat + ptr->size;
    			cur->start_locat = _head->start_locat + _head->size;
    			cur->size = cur->size - _head->size;
    			break;
    		}
    		else if (cur->status == 0&&cur->size == _head->size)
    		{
    			cur->pid = _head->pid;
    			cur->status = 1;
    			free_num--;
    			break;
    		}
    		ptr = ptr->next;
    	}
    	if (ptr->next->status == 0)
    	{
    		cout << "没有适合的申请位置" << endl;
    	}
    }
    void Next_fit(PNode list)
    {
    	assert(NULL != list);
    	PNode _head = Insert_Node();
    	PNode p = list;
    	if (Flag_Node != NULL)
    	{
    		p = Flag_Node;
    	}
    	PNode ptr = p;
    	while (ptr->next != p)
    	{
    		PNode cur = ptr->next;
    		if (cur->status == 0 && cur->size > _head->size)
    		{
    			_head->next = cur;
    			_head->perior = ptr;
    			cur->perior = _head;
    			ptr->next = _head;
    			_head->status = 1;
    			_head->start_locat = ptr->start_locat + ptr->size;
    			cur->start_locat = _head->start_locat + _head->size;
    			cur->size = cur->size - _head->size;
    			Flag_Node = _head;
    			break;
    		}
    		else if (cur->status == 0 && cur->size == _head->size)
    		{
    			cur->pid = _head->pid;
    			cur->status = 1;
    			Flag_Node = cur;
    			free_num--;
    			break;
    		}
    		ptr = ptr->next;
    	}
    	if (ptr->next->status == 0)
    	{
    		cout << "没有适合的申请位置" << endl;
    	}
    }
    long* _Sort_min(long* p)
    {
    	assert(NULL != p);
    	for (int i = 0; i < free_num-1; i++)
    	{
    		for (int j = 0; j < free_num - 1 - i; j++)
    		{
    			if (p[j] > p[j + 1])
    			{
    				long tmp = p[j];
    				p[j] = p[j + 1];
    				p[j + 1] = tmp;
    			}
    		}
    	 }
    	return p;
    }
    void Best_fit(PNode list)
    {
    	assert(NULL != list);
    	PNode _head = Insert_Node();
    	long* p = (long*)malloc(sizeof(long)*(free_num));
    	assert(NULL!=p);
    	PNode ptr = list->next;
    	long i = 0, j = 0;
    	while (ptr!= list)
    	{
    		if (ptr->status == 0)
    		{
    			*(p+i) = ptr->size;
    			i++;
    		}
    		ptr = ptr->next;
    	}
    	long* q = _Sort_min(p);
    	while (j < free_num)
    	{
    		if (_head->size < q[j])
    		{
    			break;
    		}
    		j++;
    	}
    	PNode cur = list;
    	while (cur->next != list)
    	{
    		PNode tr = cur->next;
    		if (tr->status==0&&tr->size == q[j])
    		{
    			if (_head->size < tr->size)
    			{
    				_head->next = tr;
    				_head->perior = cur;
    				tr->perior = _head;
    				cur->next = _head;
    				_head->status = 1;
    				_head->start_locat = cur->start_locat + cur->size;
    				tr->start_locat = _head->start_locat + _head->size;
    				tr->size = tr->size - _head->size;
    				break;
    			}
    			else if(_head->size==tr->size)
    			{
    				tr->pid = _head->pid;
    				tr->status = 1;
    				break;
    			}
    		}
    		cur = cur->next;
    	}
    }
    long* _Sort_max(long* p)
    {
    	assert(NULL != p);
    	for (int i = 0; i < free_num - 1; i++)
    	{
    		for (int j = 0; j < free_num - 1 - i; j++)
    		{
    			if (p[j] <= p[j + 1])
    			{
    				long tmp = p[j];
    				p[j] = p[j + 1];
    				p[j + 1] = tmp;
    			}
    		}
    	}
    	return p;
    }
    void Worst_fit(PNode list)
    {
    	assert(NULL != list);
    	PNode _head = Insert_Node();
    	long* p = (long*)malloc(sizeof(long) * (free_num));
    	assert(NULL != p);
    	PNode ptr = list->next;
    	long i = 0, j = 0;
    	while (ptr != list)
    	{
    		if (ptr->status == 0)
    		{
    			*(p + i) = ptr->size;
    			i++;
    		}
    		ptr = ptr->next;
    	}
    	long* q = _Sort_max(p);
    	PNode cur = list;
    	while (cur->next != list)
    	{
    		PNode tr = cur->next;
    		if (tr->status == 0 && tr->size == q[j])
    		{
    			if (_head->size < tr->size)
    			{
    				_head->next = tr;
    				_head->perior = cur;
    				tr->perior = _head;
    				cur->next = _head;
    				_head->status = 1;
    				_head->start_locat = cur->start_locat + cur->size;
    				tr->start_locat = _head->start_locat + _head->size;
    				tr->size = tr->size - _head->size;
    				break;
    			}
    			else if (_head->size == tr->size)
    			{
    				tr->pid = _head->pid;
    				tr->status = 1;
    				break;
    			}
    		}
    		cur = cur->next;
    	}
    }
    void Release_Mem(PNode list)
    {
    	assert(NULL != list);
    	int delet_id = 0;
    	cout << "请输入需要回收的进程号:" << endl;
    	cin >> delet_id;
    	PNode ptr = list;
    	while (ptr->next != list)
    	{
    		PNode cur = ptr->next;
    		if (cur->pid == delet_id)
    		{
    			if (cur->status == 0)
    			{
    				cout << "回收错误请输入正确进程号" << endl;
    				break;
    			}
    			else
    			{
    				if (ptr->status == 0&&cur->next->status==1)//1
    				{
    					ptr->size = ptr->size + cur->size;
    					cur->next->perior = ptr;
    					ptr->next = cur->next;
    					free(cur);
    					cur = NULL;
    					break;
    				}
    				else if (ptr->status == 1 && cur->next->status == 0)//2
    				{
    					PNode p = cur->next;
    					cur->size = cur->size + p->size;
    					p->next->perior = cur;
    					cur->next = p->next;
    					cur->status = 0;
    					free(p);
    					p = NULL;
    					break;
    				}
    				else if (ptr->status == 0 && cur->next->status == 0)//3
    				{
    					PNode p = cur->next;
    					ptr->size = cur->size + ptr->size + p->size;
    					p->perior = ptr;
    					ptr->next = p;
    					free(cur);
    					cur = NULL;
    					p->next->perior = ptr;
    					ptr->next = p->next;
    					free(p);
    					p = NULL;
    					free_num--;
    					break;
    				}
    				else//4
    				{
    					cur->status = 0;
    					free_num++;
    					break;
    				}
    				
    			}
    			
    		}
    		ptr = ptr->next;
    	}
    }
    void Show(PNode list)
    {
    	assert(NULL != list);
    	printf("分区号码  分区大小  分区始址  分区状态\n"); 
    	PNode ptr = list;
    	while (ptr->next!=list)
    	{    
    		ptr = ptr->next;
    		if (ptr->status == 0)
    		{
    			printf("%6d    %6dk    %6dk      空闲\n",ptr->pid, ptr->size,ptr->start_locat);
    		}
    		else
    		{
    			printf("%6d    %6dk    %6dk      占用\n",ptr->pid, ptr->size, ptr->start_locat);
    		}
    		
    	}
    }
    

    .cpp文件(主函数)

    int main()
    {
    	struct Node head;
    	int select = 1;
    	cout << "请输入请初始化内存块的首地址及内存大小:" << endl;
    	cin >> start_add >> memory_size;
    	if (memory_size > MAX_ALLOC_SIZE) {
    		cout << "申请内存超过内存大小阈值!" << endl;
    		return -1;
    	}
    	Init_list(&head);
    	Creat_list(&head);
    	Show(&head);
    	while (1)
    	{
    		cout << "******************************************\n";
    		cout << "*****1.******* 首次适应算法 ************\n";
    		cout << "*****2.******循环首次适应算法 ************\n";
    		cout << "*****3.******  最佳适应算法   ************\n";
    		cout << "*****4.******  最坏适应算法   ************\n";
    		cout << "*****5.*******   回收内存    *********\n";
    		cout << "*****0.**********退出*********************\n";
    		cout << "请选择:> ";
    		cin >> select;
    		switch (select)
    		{
    		case 1:
    			First_fit(&head);
    			Show(&head);
    			break;
    		case 2:
    			Next_fit(&head);
    			Show(&head);
    			break;
    		case 3:
    			Best_fit(&head);
    			Show(&head);
    			break;
    		case 4:
    			Worst_fit(&head);
    			Show(&head);
    			break;
    		case 5:
    			Release_Mem(&head);
    			Show(&head);
    			break;
    		default:
    			break;
    		}
    	}
    	return 0;
    }
    

    第一次写不太好见谅

    (1)以首地址为0内存大小1024对链表初始化
    在这里插入图片描述
    (2)选用首次适应算法申请分区号为4大小为428的进程:

    在这里插入图片描述
    (3)为了方便 进行回收算法 第二第四未被回收。注意:回收有四种状态
    在这里插入图片描述
    (4)使用最佳适应算法 申请 12 大小26的分区:

    在这里插入图片描述
    (5)使用最坏适应算法 申请 分区号15 大小为88按照最佳适应为申请在2号分区但是最坏适应在最大分区 如下:
    在这里插入图片描述
    (6)循环首次自己试去…end
    上课了 跑了。。。。。。。。。。。

    展开全文
  • 首次适应算法(First Fit):该算法从空闲分区链首开始查找,直至找到一个能满足其大小要求的空闲分区为止。然后再按照作业的大小,从该分区中划出一块内存分配给请求者,余下的空闲分区仍留在空闲分区链中。 最佳...
  • 操作系统中利用最佳适应算法 最坏适应算法 循环首次适应算法 首次适应算法实现动态内存的分配和回收内存
  • 操作系统中的实验,用C语言实现循环首次适应算法的功能

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,363
精华内容 16,545
关键字:

首次适应