动态分区存储管理系统分解
动态分区存储管理方式的主存分配回收总结
动态分区存储管理方式的主存分配回收总结动态分区存储管理是一种常见的主存分配回收技术，它通过动态创建并分配大小不等的存储块来管理主存空间，以满足不同进程的需求。
这种管理方式在操作系统中起着至关重要的作用，因此本文将对动态分区存储管理的主存分配回收进行总结，从原理、特点、优缺点及其在实际应用中的情况进行阐述。
一、原理动态分区存储管理是基于分区的主存管理机制，它将主存空间划分为多个不等大小的分区，每个分区可以被分配给一个进程使用。
当系统收到一个新进程的请求时，它会根据需要的主存大小为进程分配一个合适大小的分区。
当进程执行完毕，系统会回收该进程所占用的分区，使得该空间可以再次被分配给其他进程使用。
在动态分区存储管理中，主要有两种分配方式：首次适应算法和最佳适应算法。
首次适应算法是从第一个满足大小要求的分区开始进行分配；而最佳适应算法是从所有满足大小要求的分区中选择最小的分区进行分配。
这两种分配方式都有自己的优点和局限性，但它们都是基于动态分区存储管理的基本原理。
二、特点1.灵活性动态分区存储管理可以根据进程的需求动态地分配和回收主存空间，提高了主存的利用率和效率。
进程可以根据需要申请和释放主存空间，而无需预先分配固定大小的空间。
2.节省空间动态分区存储管理可以尽可能地利用主存中的碎片空间，减少了外部碎片的浪费。
这种管理方式能够充分利用主存空间，提高了主存的利用率。
3.多样性动态分区存储管理可以适应不同大小的进程需求，能够根据进程的大小灵活地进行分区分配，满足了不同进程的需求。
三、优缺点1.优点（1）提高了主存的利用率和效率。
（2）灵活地分配和回收主存空间，满足不同进程的需求。
（3）节省了主存空间，减少了碎片的浪费。
2.缺点（1）会产生外部碎片，影响了分区空间的利用率。
（2）分配和回收过程中可能产生较大的开销，影响了系统的性能。
四、在实际应用中的情况动态分区存储管理在操作系统中得到了广泛的应用，特别是在多道程序设计和实时系统中。
存储管理动态分区分配及回收算法
存储管理动态分区分配及回收算法存储管理是计算机系统中的重要组成部分，它负责管理和分配计算机中的物理内存资源。
在计算机系统中，通过动态分区分配和回收算法来实现对这些资源的有效利用。
本文将介绍动态分区分配和回收算法的原理、主要算法以及优缺点。
动态分区分配是一种灵活、动态的内存分配方式，它根据进程的需求动态地分配内存空间。
动态分区分配算法有多种，其中最常用的有首次适应算法、最佳适应算法和最坏适应算法。
首次适应算法（First Fit）是最常用的分配算法之一、它从低地址开始寻找第一个满足要求的空闲分区来分配进程。
这种算法的优点是简单、高效，但是可能会产生大量的碎片空间，降低内存的利用率。
最佳适应算法（Best Fit）是在所有空闲分区中找到一个大小最适合进程的分区来分配。
它的主要思想是选择一个更接近进程大小的空闲分区，以减少碎片空间的产生。
然而，这种算法的缺点是需要遍历整个空闲分区链表，因此效率相对较低。
最坏适应算法（Worst Fit）与最佳适应算法相反，它选择一个大小最大的空闲分区来分配进程。
这种算法的好处是可以尽可能地保留大块的碎片空间，以便后续分配使用。
但是，它也会导致更多的碎片空间浪费。
动态分区的回收算法是用于回收被释放的内存空间并合并相邻的空闲分区，以尽量减少碎片空间的产生。
常见的回收算法有合并相邻空闲分区算法和快速回收算法。
合并相邻空闲分区算法会在每次有分区被回收时，检查是否有相邻的空闲分区可以合并。
如果有，就将它们合并为一个大的空闲分区。
这样可以最大程度地减少碎片空间，提高内存的利用效率。
快速回收算法是一种将被释放的分区插入到一个空闲分区链表的头部，而不是按照地址顺序进行插入的算法。
这样可以减少对整个空闲分区链表的遍历时间，提高回收的效率。
总结起来，动态分区分配和回收算法在存储管理中起着重要的作用。
首次适应算法、最佳适应算法和最坏适应算法是常用的动态分区分配算法，它们各自有着不同的优缺点。
操作系统-存储管理动态分区分配及回收算法(附源码)
存储管理动态分区分配及回收算法课程名称:计算机操作系统班级:信1501-2实验者姓名：李琛实验日期：2018年5月20日评分：教师签名：一、实验目的分区管理是应用较广泛的一种存储管理技术。
本实验要求用一种结构化高级语言构造分区描述器，编制动态分区分配算法和回收算法模拟程序，并讨论不同分配算法的特点.二、实验要求1、编写:First Fit Algorithm2、编写：Best Fit Algorithm3、编写：空闲区回收算法三、实验过程（一）主程序1、定义分区描述器node，包括3 个元素:（1)adr-—分区首地址(2）size——分区大小(3)next——指向下一个分区的指针2、定义3 个指向node 结构的指针变量：(1）head1——空闲区队列首指针（2）back1-—指向释放区node 结构的指针（3）assign——指向申请的内存分区node 结构的指针3、定义1 个整形变量：free——用户申请存储区的大小（由用户键入）（二)过程1、定义check 过程，用于检查指定的释放块（由用户键入）的合法性2、定义assignment1 过程，实现First Fit Algorithm3、定义assignment2 过程，实现Best Fit Algorithm4、定义acceptment1 过程，实现First Fit Algorithm 的回收算法5、定义acceptment2 过程，实现Best Fit Algorithm 的回收算法6、定义print 过程，打印空闲区队列（三）执行程序首先申请一整块空闲区，其首址为0，大小为32767；然后，提示用户使用哪种分配算法，再提示是分配还是回收；分配时要求输入申请区的大小，回收时要求输入释放区的首址和大小。
实验代码Main。
cpp#include〈stdio。
h〉#include<stdlib.h>#include〈string。
动态分区分配存储管理系统
动态分区分配存储管理系统一、设计目的与内容用高级语言编写和调试一个动态分区内存分配程序，演示实现下列两种动态分区分配算法1）首次适应算法2）循环首次适应算法1.内存中有0-100M的空间为用户程序空间，最开始用户空间是空闲的。
2.作业数量、作业大小、进入内存时间、运行时间需要通过界面进行输入。
3.可读取样例数据（要求存放在外部文件中）进行作业数量、作业大小、进入内存时间、运行时间的初始化。
4.根据作业进入内存的时间，采用简单的先进先出原则进行从外存到内存的调度，作业具有等待（从外存进入内存执行）、装入（在内存可执行）、结束（运行结束，退出内存）三种状态。
5.能够自动进行内存分配与回收，可根据需要自动进行紧凑与拼接操作。
二、算法的基本思想1、定义基本结构：1作业结构：typedefstructJOB{intnum;//作业号intsize;//作业大小intctime;//作业进入时间intrtime;//作业运行时间intstate;//作业状态}Job;2）分区结构：typedefstructDuLNode{intID;//分区号intstart;//开始地址intsize;//大小intstate;//0=尚未使用1=使用2=释放structDuLNode*prior;〃前驱指针structDuLNode*next;//后即指针}DuLNode,*DuLinkList;2、基本操作：intFirstfit(int);//首次适应算法intNext_fit(int);//循环首次适应算法voidshowJob(int);//显示作业表voidshowPartiton(DuLinkList);//显示分区表DuLinkListInitpartitionList(DuLinkList&p);//初始化voidhuishou(DuLinkListpl3,DuLinkList&pl);//回收函数intPutin(int&口)；//输入函数，输入作业相关信息3、首次适应算法空闲分区链以地址递增的次序链接，分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区为止；然后再按照作业的大小，从该分区中划出一块内存空间分配给请求者，取消的空闲分区仍留在空闲链中。
动态分区分配存储管理系统
动态分区分配存储管理系统一、设计目的与内容用高级语言编写和调试一个动态分区内存分配程序，演示实现下列两种动态分区分配算法1）首次适应算法2）循环首次适应算法1. 内存中有0-100M 的空间为用户程序空间，最开始用户空间是空闲的。
2. 作业数量、作业大小、进入内存时间、运行时间需要通过界面进行输入。
3. 可读取样例数据（要求存放在外部文件中）进行作业数量、作业大小、进入内存时间、运行时间的初始化。
4. 根据作业进入内存的时间，采用简单的先进先出原则进行从外存到内存的调度，作业具有等待（从外存进入内存执行）、装入（在内存可执行）、结束（运行结束，退出内存）三种状态。
5. 能够自动进行内存分配与回收，可根据需要自动进行紧凑与拼接操作。
二、算法的基本思想1、定义基本结构：1作业结构：typedef struct JOB{int num; //作业号int size; //作业大小int ctime; //作业进入时间int rtime; //作业运行时间int state; //作业状态}Job;2)分区结构：typedef struct DuLNode{int ID; //分区号int start; //开始地址int size; //大小int state; //0=尚未使用1=使用2=释放struct DuLNode *prior;//前驱指针struct DuLNode *next; //后即指针}DuLNode, * DuLinkList;2、基本操作：int Firstfit(int);//首次适应算法int Next_fit(int); //循环首次适应算法void showJob(int); //显示作业表void showPartiton(DuLinkList);//显示分区表DuLinkList InitpartitionList(DuLinkList &p);//初始化void huishou(DuLinkList pl3,DuLinkList &pl);//回收函数int Putin(int &n);//输入函数，输入作业相关信息3、首次适应算法空闲分区链以地址递增的次序链接，分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区为止；然后再按照作业的大小，从该分区中划出一块内存空间分配给请求者，取消的空闲分区仍留在空闲链中。
动态分区管理方式及动态分区算法
动态分区管理方式及动态分区算法一、动态分区概述在操作系统中，内存管理是一个非常重要的部分。
在实际的应用中，程序的内存需求是会发生变化的，因此需要一种灵活的内存管理方式来满足不同程序的内存需求。
动态分区管理方式应运而生，它可以根据程序的需求，灵活地分配和回收内存空间，是一种高效的内存管理方式。
二、动态分区管理方式动态分区管理方式是指将内存划分为多个大小不等的分区，每个分区都可以被分配给进程使用，当进程终止时，分区将被回收。
动态分区管理方式通常通过动态分区算法来实现，下面将介绍几种常见的动态分区算法。
三、首次适应算法首次适应算法是最简单和最直观的动态分区分配算法。
它的基本思想是在空闲分区链表中按照位置区域顺序查找第一个能够满足进程大小需求的空闲分区，并将其分配给进程。
首次适应算法的优点是实现简单，分区利用率较高，但缺点是会产生大量的不连续碎片。
四、最佳适应算法最佳适应算法是在空闲分区链表中查找满足进程大小需求的最小空闲分区，并将其分配给进程。
最佳适应算法的优点是可以减少外部碎片，缺点是查找适合的空闲分区会花费较长的时间。
五、最坏适应算法最坏适应算法是在空闲分区链表中查找满足进程大小需求的最大空闲分区，并将其分配给进程。
最坏适应算法的优点是能够产生较小的碎片，但缺点是会导致剩余分区较多，影响分区利用率。
六、动态分区管理方式的优缺点动态分区管理方式相比于静态分区管理方式有很多优点，比如可以灵活地满足不同程序的内存需求，可以动态地合并和分割分区，提高了内存的利用率等。
但是动态分区管理方式也有一些缺点，比如会产生碎片，分配和回收内存的开销较大等。
七、结语动态分区管理方式及其算法在实际应用中有着广泛的应用，通过合理选择动态分区算法，可以提高内存的利用率，改善系统性能。
也需要注意动态分区管理方式可能产生的碎片问题，可以通过内存紧缩等手段来解决。
希望本文对读者有所帮助。
动态分区管理方式及动态分区算法八、碎片问题与解决方法在动态分区管理方式中，经常会出现碎片问题，包括内部碎片和外部碎片。
动态分区分配操作系统操作方法实验步骤
动态分区分配操作系统操作方法实验步骤1.引言1.1 概述概述部分：在计算机系统中，动态分区分配是一种重要的操作系统操作方法。
它是指在运行时根据进程的内存需求动态地将系统内存分配给进程，以实现内存资源的高效利用。
动态分区分配操作方法在现代操作系统中被广泛应用，例如Windows、Linux等。
通过合理的动态分区分配策略，可以提升系统的性能和资源利用率。
本文将对动态分区分配操作系统操作方法进行详细介绍和实验步骤的说明。
首先，我们将介绍动态分区分配的背景和意义，包括其在操作系统中的作用和应用场景。
其次，我们将详细讨论实验的具体步骤，包括如何进行动态分区分配操作、如何测试相关的性能指标等。
本文的目标是帮助读者了解动态分区分配操作系统操作方法的基本原理和实践技巧。
同时，通过实际操作和实验验证，读者将能够更好地理解动态分区分配的概念和操作过程，提升对操作系统的理解和应用能力。
在接下来的章节中，我们将分别介绍动态分区分配操作系统操作方法的背景和实验步骤，并给出相应的实例和案例分析。
最后，我们将对实验结果进行总结和展望，探讨动态分区分配操作方法的发展前景和可能的研究方向。
通过本文的阅读和实验操作，读者将能够对动态分区分配操作系统操作方法有一个全面的了解，为进一步研究和应用提供基础和指导。
同时，我们也欢迎读者对本文内容进行补充和扩展，以促进相关领域的进一步发展和应用。
1.2 文章结构文章结构部分的内容可以从以下角度进行描述：文章结构是指整篇文章的组织框架和内容安排。
合理的文章结构可以使读者更好地理解文章的主题和内容，帮助读者快速找到所需信息并形成完整的认识。
本文将按照以下结构进行论述：1. 引言：在引言部分，我们将对动态分区分配操作系统操作方法的背景和意义进行介绍，明确文章的目的和重要性。
2. 正文：正文是文章的核心部分，将分为两个要点进行叙述。
2.1 第一个要点：动态分区分配操作系统操作方法。
首先，我们将对动态分区分配的背景进行介绍，解释其在操作系统中的应用和意义。
存储管理的基本模式
存储管理的基本模式存储管理是操作系统中重要的组成部分，负责管理计算机系统中的内存和外部存储器。
存储管理的基本模式主要有以下几种：1. 固定分区固定分区是一种简单的存储管理方式，它将内存分为若干个固定大小的区域，每个区域对应一个进程或任务。
每个进程只能在自己的区域中运行，不能访问其他区域的内存。
这种方式在一定程度上限制了进程的自由度，但由于实现简单，在一些简单系统中仍然被采用。
优点：实现简单，安全可靠。
缺点：分区数量固定，造成内存浪费，且不利于大内存程序的运行。
适用场景：适用于内存较小、任务数量固定的系统。
2. 动态分区动态分区是一种更为灵活的存储管理方式，它根据进程或任务的实际需要，动态地分配内存空间。
这种方式能够更好地利用内存资源，提高内存利用率。
优点：内存利用率高，适用于大内存程序。
缺点：实现相对复杂，需要操作系统进行更多的管理操作。
适用场景：适用于内存较大、任务数量不确定的系统。
3. 页式管理页式管理是一种将内存分为若干个页（page）的存储管理方式。
每个页的大小固定，可以存放一个进程或任务的一部分。
页式管理通过将程序分割成多个页面，实现了内存的离散分配。
优点：内存利用率高，可以实现多道程序运行。
缺点：实现相对复杂，需要处理页面置换和缺页等问题。
适用场景：适用于内存较大、任务数量不确定的系统。
4. 段式管理段式管理将内存分为若干个段（segment），每个段的大小不固定，可以存放一个进程或任务的一部分。
段式管理通过将程序分割成多个段，实现了内存的逻辑分段。
优点：便于多道程序运行，可以实现分段保护和分段共享。
缺点：实现相对复杂，需要处理段之间的地址映射和保护等问题。
适用场景：适用于内存较大、任务数量不确定的系统。
5. 段页式管理段页式管理结合了页式管理和段式管理的优点，将内存分为若干个段，每个段又包含若干个页。
这种方式可以实现内存的逻辑分段和离散分配，同时提高了内存的利用率和多道程序运行能力。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统原理课程设计报告题目：动态分区分配存储管理系统所在学院：计算机科学与技术学院班级： 11级计算机科学与技术(非师) 学号： 20111202052姓名：吴创连指导教师：黄侠剑2014年3月18目录1 引言 (1)2 需求分析 (1)3 概要设计 (1)4 详细设计 (1)4.1问题描述和分析 (1)4.2程序流程图 (2)4.3数据结构体分析 (3)4.4主要程序代码分析 (4)5 调试与操作说明 (11)5.1初始界面 (11)5.2模拟内存分配 (12)5.3回收内存界面 (12)5.4最佳适应算法的实现 (13)5.5最坏适应算法的实现 (13)6总结与体会 (13)1 引言操作系统是最重要的系统软件，同时也是最活跃的学科之一。
我们通过操作系统可以理解计算机系统的资源如何组织，操作系统如何有效地管理这些系统资源，用户如何通过操作系统与计算机系统打交道。
存储器是计算机系统的重要组成部分，近年来，存储器容量虽然一直在不断扩大，但仍不能满足现代软件发展的需要，因此，存储器仍然是一种宝贵而又紧俏的资源。
如何对它加以有效的管理，不仅直接影响到存储器的利用率，而且还对系统性能有重大影响。
而动态分区分配属于连续分配的一种方式，它至今仍在内存分配方式中占有一席之地。
2 需求分析动态分区分配是根据进程的实际需要，动态地为之分配内存空间。
在实现动态分区分配时，将涉及到分区分配中所用的数据结构、分区分配算法和分区的分配和回收操作这样三个问题。
常用的数据结构有动态分区表和动态分区链。
在对数据结构有一定掌握程度的情况下设计合理的数据结构来描述存储空间，实现分区存储管理的内存分配功能，应该选择最合适的适应算法（最佳适应算法，最坏适应算法），在动态分区存储管理方式中主要实现内存分配和内存回收算法，在这些存储管理中间必然会有碎片的产生，当碎片产生时，进行碎片的拼接等相关的内容。
3 概要设计本程序采用机构化模块化的设计方法，共分为两大模块。
1．最佳适应算法实现它从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区，这种方法能使碎片尽量小。
为适应此算法，空闲分区表（空闲区链）中的空闲分区要按从小到大进行排序，自表头开始查找到第一个满足要求的自由分区分配。
2.最坏算法实现最坏适应分配算法要扫描整个空闲分区或链表，总是挑选一个最大的空闲分区分割给作业使用。
该算法要求将所有的空闲分区按其容量从大到小的顺序形成一空闲分区链，查找时只要看第一个分区能否满足作业要求。
4 详细设计4.1 问题描述和分析系统应利用某种分配算法，从空闲分区链表中找到所需大小的分区，如果空闲分区大小大于请求分区大小，则从该分区中按改请求的大小划分出一块内存空间大小划分出一块内存空间分配出去，余下的部分仍留在空闲链表中。
然后，将分配区的首址返回给调用者。
当进程运行完毕师范内存时，系统根据回收区的首址，从空闲区中找到相应的插入点，此时可能出现以下四种情况之一：⑴该空闲区的上下两相邻分区都是空闲区：将三个空闲区合并为一个空闲区。
新空闲区的起始地址为上空闲区的起始地址，大小为三个空闲区之和。
空闲区合并后，取消可用表或自由链中下空闲区的表目项或链指针，修改上空闲区的对应项。
⑵该空闲区的上相邻区是空闲区：将释放区与上空闲区合并为一个空闲区，其起始地址为上空闲区的起始地址，大小为上空闲区与释放区之和。
合并后，修改上空闲区对应的可用表的表目项或自由链指针。
⑶该空闲区的下相邻区是空闲区：将释放区与下空闲区合并，并将释放区的起始地址作为合并区的起始地址。
合并区的长度为释放区与下空闲区之和。
同理，合并后修改可用表或自由链中相应的表目项或链指针。
⑷两相邻区都不是空闲区：释放区作为一个新空闲可用区插入可用表或自由链。
4.2 程序流程图内存分配流程图，如图4-1所示。
从头开始查表检索完否？分区大小>所需大小分区大小-所需大小<=不可再分割大小从该分区中划出所需大小的新分区将该分区分配给请求者修改有关数据结构返回继续检索下一个表项将该分区从链中移出返回YYY NNN内存回收流程图，如图4-2所示。
开始判断空闲区上下内存情况上为空下为空上下都为空上下都不为空将上面的空闲区合并，并回收将下面的空闲区合并，并回收将上下的空闲区合并，并回收直接将其回收结束4.3 数据结构体分析⑴进程属性结构体typedef struct readyque{char name[10];int size;}readyque,*readyqueue;⑵空闲链表结构体typedef struct idlyspace{int from;int size;idlyspace * next;}idlyspace,*idly;⑶已分配链表结构体typedef struct busyspace{int from;readyque r;busyspace * next;}busyspace,*busy4.4主要程序代码分析#include<iostream>#include<malloc.h>#include<stdio.h>using namespace std;typedef struct readyque//进程的属性结构体{char name[10];int size;}readyque,*readyqueue;typedef struct idlyspace//空闲表结构体{int from;int size;idlyspace * next;}idlyspace,*idly;typedef struct busyspace//已分配链表结构体{int from;readyque r;busyspace * next;}busyspace,*busy;static idly Is;static idly Is2;static busy Bs;int bestfit();int worstfit();int recover();void Isprint();void Bsprint();int main(){Is=(idly)malloc(sizeof(idlyspace));Is->from=0;Is->size=100;Is->next=NULL;Is2=Is;Bs=(busy)malloc(sizeof(busyspace));Bs->next=NULL;int t,t1;l1: printf("|********欢迎来到动态分区存储管理系统***************|\n");printf("|请选择要执行的算法: |\n");printf("| 1.最佳适应算法|\n");printf("| 2.最差适应算法|\n");printf("|***************************************************|\n");printf("请输入您的选择:");scanf("%d",&t);system("cls");//int i;while(i!=0){printf("|**************************************************|\n");printf("| 操作菜单如下：|\n");printf("| 1.分配空间 2.回收空间|\n");printf("| 3.返回上级 4.退出|\n");printf("|**************************************************|\n");scanf("%d",&i);system("cls");switch(i){case 1:switch(t){case 1:t1=bestfit();break;case 2:t1=worstfit();break;default:printf("选择算法错误\n");return 1;}if(t1)printf("分配空间成功\n");elseprintf("分配空间失败\n");Bsprint();Isprint();break;case 2:t1=recover();if(t1)printf("回收成功\n");elseprintf("回收失败\n");Bsprint();Isprint();break;case 3:goto l1;case 4:exit(0);default:printf("输入错误，重新输入\n");}}return 0;}int bestfit()//最佳适应算法{int t=0;readyque D;printf("请输入进程名:\n");scanf("%s",);printf("输入进程申请空间大小:\n");scanf("%d",&D.size);idly l=Is;idly min=NULL;int mt=100;busy b=Bs;while(l) //在空闲链中寻找第一个大于所输入的进程大小的空闲块{if(D.size<=l->size){if(D.size<mt){mt=l->size;min=l;t=1;mt=mt-D.size;}l=l->next;}if(mt!=100)//找到第一个满足要求的空闲块{busy j;j=(busy)malloc(sizeof(busyspace));//申请分配用于存放进程的内存空间j->from=min->from;//将第一个满足要求的空闲块（min）的首地址赋给jfor(int i=0;i<10;i++)//将所申请的进程名赋给j{j->[i]=[i];}j->r.size=D.size;//将所申请的内存大小赋给jwhile(b->next)//按从小到大的顺序查找新进程在已分配区中的位置{if(b->next->from<j->from)b=b->next;elsebreak;}j->next=b->next;b->next=j; //将所输入的进程插入进程链min->from=min->from+D.size;//改变该空闲块的起始地址min->size=min->size-D.size;//改变该空闲块的剩余大小}return t;}int worstfit()//最坏适应算法{int t=0;readyque D;printf("请输入进程名:\n");scanf("%s",);printf("输入进程申请空间大小:\n");scanf("%d",&D.size);//输入进程申请的空间大小idly l=Is;//l指向空闲链表ls头idly min=NULL;int mt=0;busy b=Bs;//b指向已分配链表Bs头//找到空闲分区中大小满足进程的请求且尺寸最大的结点while(l){if(D.size<=l->size)//判断进程所申请的大小是否小于空闲区的各结点大小if(l->size>mt){mt=l->size;min=l;//min指向空闲区中尺寸最大的结点t=1;}}l=l->next;//l指向空闲链表下一个结点}if(mt!=0)//判断是否找到了空闲区的满足结点{busy j;j=(busy)malloc(sizeof(busyspace));j->from=min->from;for(int i=0;i<10;i++){j->[i]=[i];}j->r.size=D.size;while(b->next)//寻找插入到已分配链表中的位置{if(b->next->from<j->from)b=b->next;elsebreak;}//把此进程结点j插入到已分配链表中j->next=b->next;b->next=j;//修改空闲链表的相应结点的参数min->from=min->from+D.size;min->size=min->size-D.size;}return t;}int recover(){readyque D;printf("请输入想要回收的进程名\n");scanf("%s",);busy b=Bs;idly l=Is;while(b->next) //查找输入的进程名是否在已分配链表中{bool yo=1;for(int i=0;i<10;i++){if(b->next->[i]==[i])yo=yo*1;elseyo=0;}//如果在已分配链表中则释放该结点所占空间if(yo){int t=b->next->from;int ts=b->next->r.size;while(l){if(l->from>t+ts)//所回收进程与空闲结点上下都不邻接{idly tl;tl=(idly)malloc(sizeof(idlyspace));tl->from=t;tl->size=ts;tl->next=l;Is=tl;break;}if(l->from==t+ts)//所回收进程与空闲结点下邻接{l->from=t;l->size=l->size+ts;busy tb=b->next;b->next=b->next->next;free(tb);return 1;}if(l->from+l->size<t)//所回收进程与空闲结点上下都不邻接{idly tl;tl=(idly)malloc(sizeof(idlyspace));tl->from=t;tl->size=ts;tl->next=l->next;l->next=tl;break;}else if(l->from+l->size==t)//所回收进程与空闲结点上邻接{l->size=l->size+ts;if(l->from+l->size==l->next->from)//所回收进程与空闲结点上下都邻接{l->size=l->size+l->next->size;idly tm=l->next;l->next=l->next->next;free(tm);}break;}l=l->next;}//从已分配链表中释放所回收进程busy tb=b->next;b->next=b->next->next;free(tb);return 1;}b=b->next;}printf("没找到这个进程\n");return 0;}void Isprint()//输出空闲表中进程的属性值{idly t=Is;printf("---------************空闲分区表***********---------\n");printf("进程名\t\t起始地址\t大小\n");while(t){printf("%s\t\t%4d\t\t%4d\n",0,t->from,t->size);t=t->next;}}void Bsprint()//输出已分配表中进程的属性值{busy t=Bs->next;printf("-----------**********已分配分区表*********---------\n");printf("进程名\t\t起始地址\t大小\n");while(t){printf("%s\t\t%4d\t\t%4d\n",t->,t->from,t->r.size);t=t->next;}}5 调试与操作说明5.1初始界面程序初始界面，有两个块选择，选择要执行的算法，调试以最佳算法为例，如图5-1和5-2所示。