动态分区分配 最佳 最坏 适应算法
最坏适应算法

课程设计(论文)题 目: 院 (系): 专业班级: 姓 名: 学 号: 指导教师:最坏适应算法 机械电子工程系 c 运算机 2020xx 000xxx2021 年 12 月 18 日西安建筑科技大学华清学院课程设计(论文)任务书专业班级:运算机1101 学生姓名: xx 指导教师(签名):一、课程设计(论文)题目 动态分区分配-最坏适应算法:编写一个进程调度程序,采用最坏适应算法对内存块进行分配和回收,同时显示内存块分配和回收后空闲 内存分区链的情况。
二、本次课程设计(论文)应达到的目的操作系统课程实践性比较强。
课程设计是加强学生实践能力的一个 强有力手段。
课程设计要求学生在完成程序设计的同时能够写出比较规 范的设计报告。
严格实施课程设计这一环节,对于学生基本程序设计素 养的培养和软件工作者工作作风的训练,将起到显著的促进作用。
本题目要达到目的:了解动态分区分配中使用的数据结构和分配算 法,并进一步加深对动态分区存储管理方式及其实现过程的理解。
三、本次课程设计(论文)任务的主要内容和要求(包括原始数据、技 术参数、设计要求等)最坏适应分配算法要扫描整个空闲分区或链表,总是挑选一个最大 的空闲分区分割给作业使用。
该算法要求将所有的空闲分区按其容量从 大到小的顺序形成一空闲区链,查找时只要看第一个分区能否满足作业 要求。
实现采用最坏适应算法的动态分区分配过程 alloc()和回收过程 free()。
其中,空闲分区通过空闲分区链表来管理,在进行内存分配时, 系统优先使用空闲区低端的空间。
四、应收集的资料及主要参考文献:操作系统经典算法的编程实现资料非常丰富,可以在图书馆找书籍 或在因特网上找资料,都很容易找到,但是大部分代码是不全的,不能 直接运行,希望大家只是把它当参考,编码还是自己做。
参考文献: 【1】汤小丹、梁红兵、哲凤屏、汤子瀛 编著.计算机操作系统(第 三版).西安:西安电子科技大学出版社, 【2】史美林编.计算机操作系统教程.北京:清华大学出版社, 【3】徐甲同编著.操作系统教程.西安:西安电子科技大学出版社,【4】Clifford,编著.数决结构与算法分析(C++版).北京:电子工 业出版社, 【5】蒋立翔编著.C++程序设计技能百练.北京:中国铁道出版社, 五、审核批准意见教研室主任(签字)目录1.设计目的 ...................................................................... 错误!未定义书签。
动态分区管理方式及动态分区算法

动态分区管理方式及动态分区算法一、动态分区概述在操作系统中,内存管理是一个非常重要的部分。
在实际的应用中,程序的内存需求是会发生变化的,因此需要一种灵活的内存管理方式来满足不同程序的内存需求。
动态分区管理方式应运而生,它可以根据程序的需求,灵活地分配和回收内存空间,是一种高效的内存管理方式。
二、动态分区管理方式动态分区管理方式是指将内存划分为多个大小不等的分区,每个分区都可以被分配给进程使用,当进程终止时,分区将被回收。
动态分区管理方式通常通过动态分区算法来实现,下面将介绍几种常见的动态分区算法。
三、首次适应算法首次适应算法是最简单和最直观的动态分区分配算法。
它的基本思想是在空闲分区链表中按照位置区域顺序查找第一个能够满足进程大小需求的空闲分区,并将其分配给进程。
首次适应算法的优点是实现简单,分区利用率较高,但缺点是会产生大量的不连续碎片。
四、最佳适应算法最佳适应算法是在空闲分区链表中查找满足进程大小需求的最小空闲分区,并将其分配给进程。
最佳适应算法的优点是可以减少外部碎片,缺点是查找适合的空闲分区会花费较长的时间。
五、最坏适应算法最坏适应算法是在空闲分区链表中查找满足进程大小需求的最大空闲分区,并将其分配给进程。
最坏适应算法的优点是能够产生较小的碎片,但缺点是会导致剩余分区较多,影响分区利用率。
六、动态分区管理方式的优缺点动态分区管理方式相比于静态分区管理方式有很多优点,比如可以灵活地满足不同程序的内存需求,可以动态地合并和分割分区,提高了内存的利用率等。
但是动态分区管理方式也有一些缺点,比如会产生碎片,分配和回收内存的开销较大等。
七、结语动态分区管理方式及其算法在实际应用中有着广泛的应用,通过合理选择动态分区算法,可以提高内存的利用率,改善系统性能。
也需要注意动态分区管理方式可能产生的碎片问题,可以通过内存紧缩等手段来解决。
希望本文对读者有所帮助。
动态分区管理方式及动态分区算法八、碎片问题与解决方法在动态分区管理方式中,经常会出现碎片问题,包括内部碎片和外部碎片。
动态分区分配操作系统操作方法实验步骤

动态分区分配操作系统操作方法实验步骤1.引言1.1 概述概述部分:在计算机系统中,动态分区分配是一种重要的操作系统操作方法。
它是指在运行时根据进程的内存需求动态地将系统内存分配给进程,以实现内存资源的高效利用。
动态分区分配操作方法在现代操作系统中被广泛应用,例如Windows、Linux等。
通过合理的动态分区分配策略,可以提升系统的性能和资源利用率。
本文将对动态分区分配操作系统操作方法进行详细介绍和实验步骤的说明。
首先,我们将介绍动态分区分配的背景和意义,包括其在操作系统中的作用和应用场景。
其次,我们将详细讨论实验的具体步骤,包括如何进行动态分区分配操作、如何测试相关的性能指标等。
本文的目标是帮助读者了解动态分区分配操作系统操作方法的基本原理和实践技巧。
同时,通过实际操作和实验验证,读者将能够更好地理解动态分区分配的概念和操作过程,提升对操作系统的理解和应用能力。
在接下来的章节中,我们将分别介绍动态分区分配操作系统操作方法的背景和实验步骤,并给出相应的实例和案例分析。
最后,我们将对实验结果进行总结和展望,探讨动态分区分配操作方法的发展前景和可能的研究方向。
通过本文的阅读和实验操作,读者将能够对动态分区分配操作系统操作方法有一个全面的了解,为进一步研究和应用提供基础和指导。
同时,我们也欢迎读者对本文内容进行补充和扩展,以促进相关领域的进一步发展和应用。
1.2 文章结构文章结构部分的内容可以从以下角度进行描述:文章结构是指整篇文章的组织框架和内容安排。
合理的文章结构可以使读者更好地理解文章的主题和内容,帮助读者快速找到所需信息并形成完整的认识。
本文将按照以下结构进行论述:1. 引言:在引言部分,我们将对动态分区分配操作系统操作方法的背景和意义进行介绍,明确文章的目的和重要性。
2. 正文:正文是文章的核心部分,将分为两个要点进行叙述。
2.1 第一个要点:动态分区分配操作系统操作方法。
首先,我们将对动态分区分配的背景进行介绍,解释其在操作系统中的应用和意义。
资源管理策略的类型

资源管理策略的类型资源管理策略是指在计算机系统中,针对不同类型的资源(如内存、CPU、磁盘等)制定的一系列管理和调度方法。
合理的资源管理策略可以提高系统的性能和效率,保证系统的稳定运行。
本文将介绍几种常见的资源管理策略类型。
一、内存管理策略内存是计算机系统中最重要的资源之一,合理的内存管理策略可以提高系统的性能和稳定性。
常见的内存管理策略有以下几种:1. 静态分区管理策略:将内存分为若干固定大小的分区,每个分区只能分配给一个进程使用。
这种策略简单高效,但会导致内存碎片问题。
2. 动态分区管理策略:根据进程的需求,动态地分配和回收内存空间。
常见的动态分区管理策略有首次适应算法、最佳适应算法和最坏适应算法等。
3. 页面置换算法:当内存不足时,需要将部分页面从内存中置换到磁盘上,以释放出内存空间。
常见的页面置换算法有最近最少使用(LRU)算法、先进先出(FIFO)算法和时钟(Clock)算法等。
二、CPU调度策略CPU是计算机系统中的核心资源,合理的CPU调度策略可以提高系统的响应速度和吞吐量。
常见的CPU调度策略有以下几种:1. 先来先服务(FCFS)调度策略:按照进程到达的顺序进行调度,不考虑进程的执行时间。
这种策略简单公平,但容易导致长作业等待时间过长。
2. 短作业优先(SJF)调度策略:选择执行时间最短的进程优先执行。
这种策略可以最大限度地减少平均等待时间,但可能导致长作业饥饿。
3. 时间片轮转(RR)调度策略:将CPU时间划分为若干时间片,每个进程在一个时间片内执行,时间片用完后切换到下一个进程。
这种策略可以平衡各个进程的响应时间,但可能导致上下文切换过多。
三、磁盘调度策略磁盘是计算机系统中常用的存储设备,合理的磁盘调度策略可以提高磁盘的访问速度和效率。
常见的磁盘调度策略有以下几种:1. 先来先服务(FCFS)调度策略:按照磁盘请求的顺序进行调度,不考虑磁盘访问时间。
这种策略简单公平,但可能导致磁盘头部移动过多。
使用最佳适应算法对内存实现模拟动态分区管理

使用最佳适应算法对内存实现模拟动态分区管理摘要:内存动态分区管理的算法是操作系统课程中一个重要内容,理解和学习不同的分区算法能够为深入学习操作系统等知识提供一定的理论知识和实践依据。
本文采用c语言程序设计出最佳适应算法来模拟计算机内存分区管理,减少内存分配时产生的碎片,以此提高操作系统的稳定性。
关键词: c语言;模拟;内存分区;分配管理;最佳适应算法中图分类号:tp301 文献标识码:a 文章编号:1006-4311(2013)16-0214-021 模拟算法的设计思想计算机操作系统的最佳适应算法(best fit)是动态内存分区分配算法的一种[1]。
它能够从全部空闲区找出满足作业要求并且最小的空闲分区,这种算法能够让产生的碎片尽量缩小。
为了提高寻找速度,这种算法要求将所有的空闲区按其内容以从小到大的顺序形成一个空闲分区链。
这样,第一次找到的能满足要求的空闲区,必然是最佳的[2]。
最佳适应算法利用的思想就是将地址相邻近的自由区与回收区进行有效地合并,通过初始化空闲区、分配空闲区、回收空闲区实现模拟的内存管理,从而尽量减少碎片的产生,并尽可能的利用内存空间。
2 模拟算法的设计2.1 定义空闲分区链结构初始化时内存分配最大值定义为35670。
全局变量申明:设置分区描述器:2.2 主函数主函数main()包括:建立头结点head;定义内存分配申请1和回收内存2的选择,如果输入1则输入申请的内存大小并调用分配函数assign1=assignment(head,application1),若assign1->address==-1则分配不成功,则调用printf()函数输出“申请失败”,否则分配成功,用assign1->address进行分配;输入2将调用printf()函数提示“输入回收区的首地址和回收区的大小”,然后用语句check=backcheck(head,back)函数判断申请是否合法,若输入合法,则调用do-while循环语句多次查找适应的节点,并再次调用printf()函数输出回收结果。
动态分区分配算法

动态分区分配算法动态分区分配算法是在计算机内存管理中使用的一种内存分配策略。
在动态分区分配算法下,内存被划分为多个大小不一的分区,每个分区可以用来存储不同大小的进程。
当一个进程需要内存时,系统会选择一个合适的分区来满足其需求。
动态分区分配算法有多种实现方式,常用的包括最先适应算法、最佳适应算法和最坏适应算法。
最先适应算法(First Fit)是最简单和最常用的动态分区分配算法之一、该算法从内存起始位置开始查找合适的分区,一旦找到一个大小大于等于所需内存大小的空闲分区,就将该进程分配给这个分区并将分区大小减去所需内存大小。
这种算法的优点是实现简单、分区利用率高,但它可能会导致较小的分区被浪费掉,从而导致外部碎片的产生。
最佳适应算法(Best Fit)是另一种常用的动态分区分配算法。
该算法从所有空闲分区中选择一个大小最适合所需内存大小的分区来分配。
相比于最先适应算法,最佳适应算法能够更好地利用内存分区,减少外部碎片的产生。
然而,该算法的实现相对复杂,并且容易产生许多较小的空闲分区,导致分区利用率降低。
最坏适应算法(Worst Fit)是另一种动态分区分配算法。
该算法选择一个大小最大的空闲分区来分配给进程,这样可以留下更多较小的空闲分区,以备将来的进程使用。
然而,最坏适应算法可能会导致较大的分区被浪费掉,从而导致外部碎片的产生。
同样,该算法的实现也相对复杂,并且分区利用率相对较低。
动态分区分配算法的选择取决于特定的应用和场景。
最先适应算法在分配速度和分区利用率方面可能更优,但可能会产生较多的外部碎片。
最佳适应算法能够更好地利用内存分区,但实现复杂,容易产生较小的空闲分区。
最坏适应算法留下较小的空闲分区,但分区利用率较低。
因此,在选择动态分区分配算法时,需要权衡这些因素,并根据特定需求进行选择。
动态分区分配算法在现代操作系统中起着重要的作用,可以有效管理内存资源,提高系统的性能和效率。
同时,动态分区分配算法也是操作系统中的一个重要研究领域,不断有新的技术和算法被提出来优化内存管理,满足日益复杂的应用需求。
广工 操作系统课程设计 最佳适应算法、最坏适应算法、循环首次适应算法

动态分区分配算法仿真,循环首次适应算法、最佳适应算法、最坏适应算法#include<iostream>#include<iomanip>//在输入输出流中用到控制符#include<windows.h>//用到了SetConsoleTextAttribute函数#define minsize 2//事先规定的不再切割的剩余分区大小为2using namespace std;struct Node{int name;int start;int size;int state;Node *pre;Node *next;};typedef struct Dlinklist{Node *head;}Dlist;//===================Dlist pro,fre;int memory,name,size,fit;Node *temp=NULL;//temp是NestFit算法中的起始查寻指针//===================void initDlist(Dlist &L)//创建带有头结点的双向链表{L.head=new Node;L.head->next=L.head->pre=NULL;}void MemoryInit()//初始化两个链表{initDlist(pro); //process链表initDlist(fre); //free block链表Node *p=new Node;p->name=0;p->start=0;p->state=0;p->size=memory;p->next=NULL;//这里曾错写成p->pre..............p->pre=fre.head;//这里曾漏写fre.head->next=p;}int getLength(Dlist &L)//返回链表的长度,即元素的个数int m=0;Node *p=L.head->next;while(p!=NULL){m++;p=p->next;}return m;}void arrangeSmaller(Dlist &L)//冒泡排序,链表按size进行排序,从小到大{int length=getLength(L);for(int i=0; i<length-1; i++)//当链表中的元素个数>=2的时候才排序{Node *p=L.head->next;Node *q=p->next;inta,b,c,d;//===================================================================== =====for(int j=0; j<length-1-i; j++){if(p->size>q->size) //交换位置,如果前面的大于后面的,使小的上浮,如果两个相等,则还是原来在前的保持在前{a=p->size;p->size=q->size;q->size=a;b=p->name;p->name=q->name;q->name=b;c=p->start;p->start=q->start;q->start=c;d=p->state;//============================================================== ============p->state=q->state;q->state=d;}p=p->next;q=p->next;}}void arrangeBigger(Dlist &L)//链表按size进行排序,从大到小{int length=getLength(L);for(int i=0; i<length-1; i++){Node *p=L.head->next;Node *q=p->next;int a,b,c,d;for(int j=0; j<length-1-i; j++){if(p->size<q->size){a=p->size;p->size=q->size;q->size=a;b=p->name;p->name=q->name;q->name=b;c=p->start;p->start=q->start;q->start=c;d=p->state;//============================================================== ============p->state=q->state;q->state=d;}p=p->next;q=p->next;}}}void arrangeStart(Dlist &L)//链表按start递增排序{int length=getLength(L);for(int i=0; i<length-1; i++){Node *p=L.head->next;Node *q=p->next;int a,b,c,d;for(int j=0; j<length-1-i; j++){if(p->start>q->start){a=p->size;p->size=q->size;q->size=a;b=p->name;p->name=q->name;q->name=b;c=p->start;p->start=q->start;q->start=c;d=p->state;//============================================================== ============p->state=q->state;q->state=d;}p=p->next;q=p->next;}}}void DlistInsert(Dlist &L,Node e) //在头结点之后插入元素,即L.head->next指向e {Node *p=new Node;p->name=;p->size=e.size;p->start=e.start;p->state=e.state;if(L.head->next!=NULL)//这是个值得注意的地方,L.head->next==NULL,则没有指针L.head->next->pre,如果这里不加判断的话,会出错L.head->next->pre=p;p->next=L.head->next;p->pre=L.head;L.head->next=p;//双向链表,插入一个新的元素,如果元素不是插入在链尾,则一共要修改四次指针}void DlistDelete(Node *p,Node &e)//传递指针p,删除指针p指向的链表元素,用Node 型变量e记录该元素的相关数据{=p->name;e.start=p->start;e.size=p->size;e.state=p->state;p->pre->next=p->next;//这里曾写成=p->pre....if(p->next!=NULL)p->next->pre=p->pre;//这里曾写成p->next->pre=p,留意delete(p); //删除一个元素修改一次或两次指针}//=======================void Green(){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSIT Y|FOREGROUND_GREEN);}void Red(){ SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSIT Y|FOREGROUND_RED);}void White(){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED|FORE GROUND_GREEN|FOREGROUND_BLUE);}void Yellow(){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSIT Y|FOREGROUND_RED|FOREGROUND_GREEN);}//=======================void BestOrWorst(){arrangeStart(fre);//先按地址递增排序if(fit==1)arrangeSmaller(fre);//再按size递增排序,当两个空闲区的size一样时,由于先按地址递增排序了,所以还是地址低的在前。
动态分区分配最佳最坏适应算法

动态分区分配最佳最坏适应算法动态分区分配是一种内存分配技术,它将内存空间划分为若干个不同大小的分区,并根据进程的内存需求,分配适当大小的分区给进程使用。
常用的动态分区分配算法有最佳适应算法、最坏适应算法和首次适应算法。
下面将详细介绍这三种算法及其特点。
1.最佳适应算法:最佳适应算法是根据进程所需内存大小,选择最佳大小的空闲分区进行分配。
具体操作是扫描所有空闲分区,选择满足进程内存需求且大小最小的分区进行分配。
这样可以最大化地利用内存,避免了大块内存被小进程占用,但是可能会出现很多碎片,影响内存空间的利用效率。
2.最坏适应算法:最坏适应算法是根据进程所需内存大小,选择最坏大小的空闲分区进行分配。
具体操作是扫描所有空闲分区,选择满足进程内存需求且大小最大的分区进行分配。
这样可以减少外部碎片的产生,但是可能会导致内存空间利用率较低,大块内存可能会被小进程占用。
3.首次适应算法:首次适应算法是根据进程所需内存大小,选择第一个满足需求的空闲分区进行分配。
具体操作是从内存的起始地址开始扫描所有空闲分区,选择满足进程内存需求的第一个分区进行分配。
这样可以快速地找到合适的分区进行分配,但可能会导致外部碎片的产生。
这三种算法各有优缺点,最佳适应算法可以最大化地利用内存空间,但是可能会产生很多碎片;最坏适应算法可以减少碎片的产生,但是可能会导致内存空间利用率较低;首次适应算法在查找分区时较为迅速,但也容易产生外部碎片。
为了更好地利用内存空间并降低碎片发生的概率,还可以使用一些优化策略,例如合并相邻的空闲分区,释放不再使用的分区等。
此外,还可以采用其他的内存分配算法,如循环首次适应算法、随机适应算法等,以根据具体情况选择适当的算法。
总之,动态分区分配是一种常用的内存管理技术,可以根据进程的内存需求进行灵活的分配。
不同的分配算法有不同的特点,可以根据具体需求选择适合的算法,并结合相应的优化策略,以提高内存利用效率和系统性能。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
我伟大的母校课程设计报告书实践课题:动态分区分配*名:***学号:20XXXXXX指导老师:***学院:计算及科学与技术学院课程设计实践时间2013.3.11~2013.3.22一.课程设计的目的:二.设计内容:三.设计要求:四.程序流程图AllocBest_fit Worst_fitFree ShowMain五.源代码#include<stdio.h>#include<stdlib.h>#include<iostream.h>#define Free 0 //空闲状态#define Busy 1 //已用状态#define OK 1 //完成#define ERROR 0 //出错#define MAX_length 100 //最大内存空间为100M 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 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<<"请输入需要分配的主存大小(单位:M):";cin>>request;if(request<0 ||request==0){cout<<"分配大小不合适,请重试!"<<endl;return ERROR;}if(ch==1) //选择最佳适应算法{if(Best_fit(request)==OK) cout<<"分配成功!"<<endl;else cout<<"内存不足,分配失败!"<<endl;return OK;}if(ch==2) //选择最差适应算法{if(Worst_fit(request)==OK) cout<<"分配成功!"<<endl;else cout<<"内存不足,分配失败!"<<endl;return OK;}}//最佳适应算法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;elsereturn 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<<"\n主存分配情况:\n";cout<<"++++++++++++++++++++++++++++++++++++++++++++++\n\n";DuLNode *p=block_first->next;cout<<"分区号\t起始地址\t分区大小\t状态\n\n";while(p){cout<<" "<<flag++<<"\t";cout<<" "<<p->data.address<<"\t\t";cout<<" "<<p->data.size<<"M\t\t";if(p->data.state==Free) cout<<"空闲\n\n";else cout<<"已分配\n\n";p=p->next;}cout<<"++++++++++++++++++++++++++++++++++++++++++++++\n\n";}//主函数void main(){int ch;//算法选择标记l1: cout<<"请输入所使用的内存分配算法:\n";cout<<"(1)最佳适应算法\n(2)最差适应算法\n";cin>>ch;while(ch<1||ch>2){cout<<"输入错误,请重新输入所使用的内存分配算法:\n";cin>>ch;}Initblock(); //开创空间表int choice; //操作选择标记while(1){show();cout<<"请输入您的操作:";cout<<"\n1: 分配内存\n2: 回收内存\n3: 返回上一层\n0: 退出\n";cin>>choice;if(choice==3){goto l1;}elseif(choice==1) alloc(ch); // 分配内存else if(choice==2) // 内存回收{int flag;cout<<"请输入您要释放的分区号:";cin>>flag;free(flag);}else if(choice==0) break; //退出else //输入操作有误{cout<<"输入有误,请重试!"<<endl;continue;}}}六.程序演示最佳适应算法最坏适应算法七.课设收获通过这次课设进一步的学习了操作系统的有关知识,锻炼了结构化程序,模块化程序的设计和调试程序的技巧。