操作系统实验_首次适应算法与循环首次适应算法
操作系统的内存分配算法
操作系统的内存分配算法操作系统的内存管理是计算机系统中一个重要的组成部分。
内存分配算法决定了如何合理地利用系统的内存资源，以达到高效、安全、稳定的运行。
本文将介绍几种常见的内存分配算法，包括首次适应算法、循环首次适应算法、最佳适应算法以及快速适应算法。
首次适应算法（First Fit Algorithm）首次适应算法是一种简单而常见的内存分配算法。
它从内存空闲列表的头部开始寻找第一个适合分配的内存块。
当找到满足要求的内存块后，将该块划分为两部分，一部分用于分配给请求的程序，另一部分保留为剩余空闲块。
这种算法的优点是分配速度较快，缺点是可能会导致内存碎片的产生。
循环首次适应算法（Next Fit Algorithm）循环首次适应算法是首次适应算法的一种改进版本。
与首次适应算法不同的是，循环首次适应算法从上一次分配的位置开始搜索空闲块，直到找到一个满足要求的内存块为止。
这样可以避免每次都从头开始搜索，提高了查找的效率。
同样，这种算法也可能导致内存碎片的产生。
最佳适应算法（Best Fit Algorithm）最佳适应算法是为了解决内存碎片问题而提出的一种分配算法。
该算法会在内存空闲列表中查找最小且能满足要求的空闲块，并将该块分配给请求的程序。
这样可以尽量充分利用内存资源，减少内存碎片的产生。
但是，最佳适应算法的缺点是分配速度相对较慢，因为需要遍历整个内存空闲列表。
快速适应算法（Quick Fit Algorithm）快速适应算法是一种综合了首次适应算法和最佳适应算法的策略。
它将内存空闲列表分成了多个不同大小的链表，每个链表分别存储相应大小的空闲块。
当有程序请求内存时，快速适应算法会直接从对应大小的链表中查找可用的空闲块进行分配，以提高分配的速度。
这个算法在时间效率和空间效率上都较为出色，但是需要付出额外的存储开销。
总结不同的内存分配算法各有优缺点，选择合适的算法取决于具体的应用场景和系统需求。
首次适应算法和循环首次适应算法适用于内存分配需求频繁变化的场景。
首次适应算法最佳适应算法最坏适应算法
首次适应算法最佳适应算法最坏适应算法首次适应算法（First Fit Algorithm）是一种常见的内存分配算法，用于管理计算机的物理内存。
它的核心思想是将内存按照从低地址到高地址的顺序进行划分，每次分配内存时从低地址开始，找到第一个足够大的空闲块来满足需求。
首次适应算法的实现相对简单，它只需要维护一个空闲内存块链表，其中存储了空闲块的起始地址和大小。
当需要分配一块内存时，首次适应算法会遍历链表，找到第一个大小足够的空闲块并将其划分为两部分：一部分用于分配，另一部分作为一个新的空闲块。
同样，当需要释放一块已分配的内存时，首次适应算法会查找内存中是否存在相邻的空闲块，若有则合并。
首次适应算法的优点是简单、高效，分配内存的时间复杂度为O(n)，其中n是空闲内存块的数量。
然而，首次适应算法也存在一些问题。
首先，它可能会导致内存碎片的产生。
当分配的内存大小比较小且频繁时，会导致大量的小块空闲内存，造成内存碎片化。
其次，由于首次适应算法是按顺序空闲块来找到最适合的块，因此可能会导致较大的块被拆分成多个小块，从而降低内存的利用率。
最佳适应算法（Best Fit Algorithm）是一种改进的内存分配算法，旨在解决首次适应算法中存在的问题。
最佳适应算法的核心思想是在每次分配内存时，选择最小的能满足需求的空闲块。
最佳适应算法的实现与首次适应算法类似，但不同之处在于它需要在遍历空闲块链表时记录下最小的满足条件的块。
当找到最小的空闲块后，将其划分为分配块和新的空闲块。
最佳适应算法的优点是减少了内存碎片的产生。
通过选择最小的能满足需求的空闲块，可以更好地利用内存。
然而，最佳适应算法的缺点是实现复杂度较高。
由于需要在空闲块链表中查找最小的块，分配内存的时间复杂度为O(n)，其中n是空闲内存块的数量。
最坏适应算法（Worst Fit Algorithm）是一种与最佳适应算法相反的内存分配算法。
它的核心思想是在每次分配内存时，选择最大的能满足需求的空闲块。
首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法
首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法是关于操作系统内存管理中内存分配策略的四种典型算法。
以下是对它们的简要解释：1. 首次适应算法（First-fit）：在内存分配时，首次适应算法从内存区域的起始部分开始搜索，找到第一个能满足请求大小的空闲内存块，并将其分配给请求者。
首次适应算法的优点是分配速度较快，但可能导致内存空间碎片化。
2. 循环首次适应算法（Next-fit）：循环首次适应算法类似于首次适应算法，但它在内存分配时保留上一次搜索的位置。
下一次分配时，算法将从上次停止的位置开始搜索，直到找到合适的空闲内存块或返回到起始位置。
这种方法可以在整个内存空间中分散分配过程，进一步改善内存碎片化问题。
3. 最佳适应算法（Best-fit）：最佳适应算法在分配内存时，会查找所有可用的空闲内存块，并分配能够最紧密地满足请求大小的内存块。
该策略试图使分配后的剩余空间尽量小，以减少内存浪费。
然而，最佳适应算法通常需要更多的搜索时间，并可能导致过多的小内存碎片。
4. 最坏适应算法（Worst-fit）：最坏适应算法与最佳适应算法相反，它在分配内存时选择最大的可用内存块。
这种策略试图保持较大的连续空闲内存块，以便满足大型请求。
然而，最坏适应算法可能导致大量空间浪费，并需要较长的搜索时间。
这些内存分配算法都有各自的优缺点。
在实际的操作系统实现中，可能会根据需求和上下文使用多种算法的组合来优化内存管理。
操作系统实验四 主存空间的分配与回收-首次适应算法和循环首次适应算法
实验报告【实验名称】首次适应算法和循环首次适应算法【实验目的】理解在连续分区动态的存储管理方式下，如何实现主存空间的分配与回收。
【实验原理】首次适应（first fit，FF）算法FF算法要求空闲分区链以地址递增的次序链接。
在分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区即可。
然后再按照作业的大小，从该分区中划出一块内存空间，分配给请求者，余下的空闲分区仍留在空闲链中。
若从链首直至链尾都不能找到一个能满足要求的分区，则表明系统中已经没有足够大的内存分配给该进程，内存分配失败，返回。
循环首次适应（next fit，NF）算法为避免低址部分留下许多很小的空闲分区，以及减少查找可用空闲分区的开销，循环首次适应算法在为进程分配内存空间时，不再是每次都从链首开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直至找到一个能满足要求的空闲分区，从中划出一块玉请求大小相等的内存空间分配给作业。
【实验内容】实现主存空间的分配与回收：1.采用可变式分区管理，使用首次适应算法实现主存空间的分配与回收；2.采用可变式分区管理，使用循环首次适应算法实现主存空间的分配与回收。
数据结构和符号说明：typedef struct PCB//进程控制块{char ProgressName[10]; //进程名称int Startaddress; //进程开始地址int ProgressSize; //进程大小int ProgressState = 0; //进程状态};typedef struct FREE //空闲区结构体{int Free_num; //空闲区名称int Startaddress; //空闲区开始地址int Endaddress; //空闲区结束地址int Free_Space; //空闲区大小};算法流程图：首次适应算法循环首次适应算法程序代码及截图：主界面：首次适应算法，初始空闲区：插入进程：插入3个进程：空闲区信息：删除进程2：删除后空闲区状况：再插入一个进程，可以看到其其初始地址为100：循环首次适应算法,插入3个进程删除进程2后：再插入进程A，发现其从上次找到的空闲分区的下一个空闲分区开始查找，其初始地址为750而不是200：。
实验四_操作系统
实验四实验报告【实验题目】：动态分区分配算法【实验目的】通过这次实验，加深对动态分区分配算法的理解，进一步掌握首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的实现方法。
【实验内容】问题描述：设计程序模拟四种动态分区分配算法：首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。
假设内存中空闲分区个数为n，空闲分区大小分别为P1, … ,P n，在动态分区分配过程中需要分配的进程个数为m（m≤n），它们需要的分区大小分别为S1, …,S m，分别利用四种动态分区分配算法将m个进程放入n个空闲分区，给出进程在空闲分区中的分配情况。
程序要求如下：1）利用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法四种动态分区分配算法模拟分区分配过程。
2）模拟四种算法的分区分配过程，给出每种算法进程在空闲分区中的分配情况。
3）输入：空闲分区个数n，空闲分区大小P1, … ,P n，进程个数m，进程需要的分区大小S1, … ,S m，算法选择1-首次适应算法，2-循环首次适应算法，3-最佳适应算法，4-最坏适应算法。
4）输出：最终内存空闲分区的分配情况。
实现提示：用C++语言实现提示：1）程序中变量定义参考（根据需要可添加）如下：const int MaxNumber=100;int FreePartition[MaxNumber];int FirstPartition[MaxNumber];int CycleFirstPartition[MaxNumber];int BestPartition[MaxNumber];int WorstPartition[MaxNumber];int ProcessNeed[MaxNumber];int PartitionNum,ProcessNum;2）页面置换的实现过程如下：变量初始化；空闲分区个数n，空闲分区大小P1, … ,P n，进程个数m，进程需要的分区大小S1, … ,S m，算法选择1-首次适应算法，2-循环首次适应算法，3-最佳适应算法，4-最坏适应算法；根据用户选择的算法进行动态分区分配；输出所有进程分配后的空闲分区分配情况。
操作系统实验报告三存储器管理实验
操作系统实验报告三存储器管理实验操作系统实验报告三：存储器管理实验一、实验目的本次存储器管理实验的主要目的是深入理解操作系统中存储器管理的基本原理和方法，通过实际操作和观察，掌握内存分配与回收的算法，以及页面置换算法的工作过程和性能特点，从而提高对操作系统资源管理的认识和实践能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。
三、实验内容1、内存分配与回收算法实现首次适应算法（First Fit）最佳适应算法（Best Fit）最坏适应算法（Worst Fit）2、页面置换算法模拟先进先出页面置换算法（FIFO）最近最久未使用页面置换算法（LRU）时钟页面置换算法（Clock）四、实验原理1、内存分配与回收算法首次适应算法：从内存的起始位置开始，依次查找空闲分区，将第一个能够满足需求的空闲分区分配给进程。
最佳适应算法：在所有空闲分区中，选择能够满足需求且大小最小的空闲分区进行分配。
最坏适应算法：选择空闲分区中最大的分区进行分配。
2、页面置换算法先进先出页面置换算法：选择最早进入内存的页面进行置换。
最近最久未使用页面置换算法：选择最近最长时间未被访问的页面进行置换。
时钟页面置换算法：给每个页面设置一个访问位，在页面置换时，从指针指向的页面开始扫描，选择第一个访问位为0 的页面进行置换。
五、实验步骤1、内存分配与回收算法实现定义内存分区结构体，包括分区起始地址、大小、是否已分配等信息。
实现首次适应算法、最佳适应算法和最坏适应算法的函数。
编写测试程序，创建多个进程，并使用不同的算法为其分配内存，观察内存分配情况和空闲分区的变化。
2、页面置换算法模拟定义页面结构体，包括页面号、访问位等信息。
实现先进先出页面置换算法、最近最久未使用页面置换算法和时钟页面置换算法的函数。
编写测试程序，模拟页面的调入和调出过程，计算不同算法下的缺页率，比较算法的性能。
首次适应算法 实验报告
首次适应算法实验报告引言首次适应算法（First Fit）是一种内存分配算法，用于解决操作系统中的内存管理问题。
在该算法中，操作系统将可用的内存空间分为若干个大小不等的分区，当一个新的作业需要分配内存时，算法通过在空闲分区列表中查找第一个能够满足作业大小的分区，找到第一个合适的位置将作业分配到该分区。
本次实验旨在通过调试和运行一个模拟的内存管理系统，了解首次适应算法的实现原理，并比较它与其他内存分配算法的性能差异。
实验环境- 操作系统：Windows 10- 开发语言：C++实验步骤和结果分析1. 设计数据结构我们首先设计了一个表示内存分区的数据结构`Partition`，包括以下成员变量：- `start`：表示分区的起始地址- `size`：表示分区的大小- `allocated`：表示分区是否已经分配给作业然后，我们设计了一个表示内存管理系统的数据结构`Memory`，包括以下成员变量：- `partitions`：表示分区列表，使用一个动态数组存储所有分区- `size`：表示内存总大小2. 实现首次适应算法在内存管理系统的实现中，我们通过设计一个`allocate`方法来实现首次适应算法的分配过程。
该方法接受一个作业的大小作为参数，返回一个指向分配的分区的指针。
如果找不到合适的分区，则返回`nullptr`。
首次适应算法的实现原理如下：- 遍历所有的分区，查找第一个未分配且大小大于作业大小的分区。
- 如果找到合适的分区，则将分区的`allocated`属性设置为`true`，表示已分配，并返回该分区的指针。
- 如果没有找到合适的分区，则返回`nullptr`。
3. 测试并分析结果在测试阶段，我们通过运行一系列的分配和释放操作来模拟作业的动态运行过程。
为了更好地观察内存的分配情况，我们将内存分为等大小的分区，并以图表的方式显示。
通过对不同大小的作业进行分配和释放测试，我们得到了如下结果：从上图可以看出，首次适应算法根据作业的大小选择不同的分区进行分配，确保了尽可能多地利用内存空间。
首次适应与循环首次适应算法实现
⾸次适应与循环⾸次适应算法实现⼀、实验内容编程实现⾸次适应与循环⾸次适应算法。
⼆、实验要求1.任选⼀种⾼级语⾔实现；三、实验过程1、 设计思想⾸次适应算法(FF):将所有空闲分区按照地址递增的次序链接，在申请内存分配时，从链⾸开始查找，将满⾜需求的第⼀个空闲分区分配给作业。
循环⾸次适应算法（NF）：将所有空闲分区按照地址递增的次序链接，在申请内存分配时，总是从上次找到的空闲分区的下⼀个空闲分区开始查找，将满⾜需求的第⼀个空闲分区分配给作业2、 数据结构public class FreeArea {private int address;//内存地址private int size;//空闲区⼤⼩public FreeArea() {}public FreeArea(int address, int size) {this.address = address;this.size = size;}public int getAddress() {return address;}public void setAddress(int address) {this.address = address;}public int getSize() {return size;}public void setSize(int size) {this.size = size;}}4、运⾏结果：四、实验代码RR.Hpackage com.hu;import java.util.Scanner;public class MemoAlloc {public static void main(String[] args) {System.out.println("======⾸次适应算法======");FreeArea freeArea[]= init();FF(freeArea);System.out.println("=====循环⾸次适应算法=====");FreeArea freeArea1[]= init();NF(freeArea1);}public static void FF(FreeArea freeArea[]){//⾸次适应算法Scanner scanner = new Scanner(System.in);System.out.println("请输⼊要分配的内存⼤⼩：");int size = scanner.nextInt();for (int i =0;i<freeArea.length;i++){if (size<=freeArea[i].getSize()){//若分配内存⼤⼩⼩于空闲分区⼤⼩则分配成功System.out.println("分配内存成功");freeArea[i].setSize(freeArea[i].getSize()-size);//修改空闲分区⼤⼩break;}if (i== freeArea.length-1&&size>freeArea[i].getSize()) System.out.println("分配失败");}}public static void NF(FreeArea freeArea[]){//循环⾸次适应Scanner scanner = new Scanner(System.in);System.out.println("请输⼊要分配的内存⼤⼩：");int size = scanner.nextInt();boolean isWhile=true;int ProcessNum =0;int j=0;for (int i=ProcessNum;i< freeArea.length;i++,j++){if (size <= freeArea[i].getSize() ) {//若分配内存⼤⼩⼩于空闲分区⼤⼩则分配成功System.out.println("分配内存成功");freeArea[i].setSize(freeArea[i].getSize() - size);ProcessNum = j+1;//下⼀次查找时从本次找到的空闲分区的下⼀个分区开始找break;}else if (ProcessNum!=0 && i== freeArea.length-1&&size>freeArea[i].getSize()){ProcessNum=0;//若开始查找时不是从链⾸开始，最后⼀个空闲分区⼤⼩仍不能满⾜要求，则返回第⼀个空闲分区}else if(ProcessNum==0&&i== freeArea.length-1&&size>freeArea[i].getSize()){System.out.println("分配失败");//若开始查找时是从链⾸开始，最后⼀个空闲分区⼤⼩仍不能满⾜要求，则分配失败};}}public static FreeArea[] init(){//空闲区初始化并排序System.out.println("初始化空闲区并分配内存地址与⼤⼩");Scanner scanner = new Scanner(System.in);FreeArea[] freeAreas = new FreeArea[5];for (int i=0;i<freeAreas.length;i++){System.out.println("请输⼊内存地址与⼤⼩：");freeAreas[i] = new FreeArea(scanner.nextInt(),scanner.nextInt());}FreeArea t;for (int i = 0;i<freeAreas.length;i++){for (int j = 0;j<freeAreas.length-1;j++){if(freeAreas[j].getAddress()>freeAreas[j+1].getAddress()){t = freeAreas[j+1];freeAreas[j+1]=freeAreas[j];freeAreas[j]=t;}}}return freeAreas;}}五、实验总结通过本次实验我更加了解了循环⾸次适应与⾸次适应算法，⾸次适应算法优先利⽤低地址部分空闲分区，保留了⾼地址部分的⼤空闲区，缺点是低址部分不断被划分，会留下很多难以利⽤的⼩的外部碎⽚，每次都从低地址部分开始查会增加查找时的开销。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
学号P7*******专业计算机科学与技术姓名实验日期2017.11.16教师签字成绩实验报告【实验名称】首次适应算法和循环首次适应算法【实验目的】学会主存空间分配与回收的基本方法首次适应算法和循环首次适应算法。
【实验原理】理解在连续分区动态的存储管理方式下，如何实现贮存空间的分配与回收。
采用可变式分区管理，使用最佳适应算法实现主存空间的分配与回收。
采用可变式分区管理，使用最坏适应算法实现主存空间的分配与回收。
数据结构：1、bool ROM[N]; //定义主存信息，如果内存被占用，则标记为1，否则标记为0，设置内存单元为10242、pcb num[20];//定义作业数组，最大支持20个作业3、typedef struct Pcb //定义作业结构体，包括名称，开始时间，大小，是否执行状态{char name[10];int start;int size;int state=0;} pcb;typedef struct Free_rom //空闲区结构体{int num;int start;int end;int space;} Free_room;Free_rom free_rom[100];//设置空闲区数组为100个主要函数void init()；//初始化信息，包括初始化内存信息，和初始化作业队列void insert_pcb1(pcb &a)；插入作业函数，首次适应算法，如果有适合的就插入，无合适输出‘插入失败’void insert_pcb1(pcb &a)；插入作业函数，循环首次适应算法，如果有适合的就插入，无合适输出‘插入失败’void Delete(pcb &a)//删除作业信息，包括修改内存状态修改作业状态并对作业进行初始化void show();//显示信息void find_free_rom() //寻找空闲区算法流程图首次适应算法循环首次适应算法程序代码及截图：#include<stdio.h>#include<string.h>#define N 1024bool ROM[N];//设置内存块int p=0;//循环首次使用需要标记当前的空闲区块typedef struct Pcb//作业数据结构{char name[10];int start;int size;int state=0;} pcb;int free_rom_counter=0;pcb num[20]; //作业队列typedef struct Free_rom //空闲区结构体{int num;int start;int end;int space;} Free_room;Free_rom free_rom[100];//设置空闲区数组为100个void find_free_rom() //寻找空闲区{free_rom_counter=0;int i,j,p;for(i=0; i<N; i++)if(ROM[i]==0){p=i;for(j=i; j<N; j++){if(ROM[j]==0){i=j;continue;}if(ROM[j]==1)//找到空闲区{free_rom_counter++;free_rom[ free_rom_counter].num= free_rom_counter;free_rom[ free_rom_counter].start=p;free_rom[ free_rom_counter].end=j-1;free_rom[ free_rom_counter].space=j-p;i=j+1;break;}}if(j==N&&ROM[j-1]==0)//对最后一个内存进行特殊操作{free_rom_counter++;free_rom[ free_rom_counter].num= free_rom_counter;//对空闲区进行处理free_rom[ free_rom_counter].start=p;free_rom[ free_rom_counter].end=j-1;free_rom[ free_rom_counter].space=j-p;}}}void init()//初始化{for(int i=0; i<N; i++)ROM[i]=0;}void show(){printf("空闲区名\t开始地址\t\t大小\t\t结束地址\t\t\n");for (int i=1; i<= free_rom_counter; i++)printf("%d\t\t%d\t\t\t%d\t\t%d\t\t\n",free_rom[ i].num,free_rom[ i].start, free_rom[ i].space,free_rom[ i].end);}void insert_pcb1(pcb &a)//首次适应算法来实现作业调度{int i,j,k;for(i=0; i<N; i++)if(ROM[i]==0){for(j=i; j<=(i+a.size)&&j<N; j++)//查询第一个空闲区，并判断是否适合插入作业if(ROM[j]==1){i=j+1;break;}if(j==i+a.size+1){a.start=i;//设置作业的开始内存a.state=1;//标记作业在内存中for(k=i; k<i+a.size&&j<N; k++)ROM[k]=1;printf("插入成功，进程%s 的初始地址为%d,结束地址为%d\n",,a.start,a.start+a.size-1);return;}}if(i==N)//未查询到合适的区域printf("插入失败，无可用空间\n");}void insert_pcb2(pcb &a)//循环首次适应算法来实现作业调度{int i,j,k;for(i=p; i<N; i++)//从所标记的当前区域开始查询，查询到末内存{if(ROM[i]==0){for(j=i; j<=(i+a.size)&&j<N; j++)if(ROM[j]==1){i=j+1;break;}if(j==i+a.size+1)//找到合适的空闲区{a.start=i;a.state=1;for(k=i; k<i+a.size&&j<N; k++)ROM[k]=1;printf("插入成功，进程%s 的初始地址为%d,结束地址为%d\n",,a.start,a.start+a.size-1);p=i+a.size;return;}}for(i=0; i<p; i++)//当未找到时，从第一个空闲区开始查询，结束条件为小于所标记的Pif(ROM[i]==0){for(j=i; j<=(i+a.size)&&j<p; j++)if(ROM[j]==1){i=j+1;break;}if(j==i+a.size+1)//成功找到结束，并标记当前P为现在的作业的尾部{a.start=i;a.state=1;for(k=i; k<i+a.size&&j<p; k++)ROM[k]=1;printf("插入成功，进程%s 的初始地址为%d\n",,a.start);p=i+a.size;break;}}if(i==p)//查询两部分都未找到合适的区域，输出插入失败语句printf("插入失败，无可用空间\n");}void Delete(pcb &a)//删除作业，修改内存信息和初始化该作业信息{int i;for(i=a.start; i<a.start+a.size; i++)ROM[i]=0;a.state=0;//状态标记为未使用printf("删除成功\n");}int main(){init();int count=0;int choose1,choose;char name[10];printf("1、首次适应算法\n");printf("2、循环首次适应算法\n");scanf("%d",&choose1);do{printf("\n\n1、插入进程\n");printf("2、删除进程\n");printf("3、显示进程的信息\n");printf("4、显示空闲区\n");scanf("%d",&choose);if(choose==1){printf("输入进程名\n");scanf("%s",&);printf("输入进程大小\n");scanf("%d",&a.size);if(choose1==1)insert_pcb1(a);else insert_pcb2(a);num[count++]=a;}else if(choose==2){printf("输入删除进程的名字\n");scanf("%s",&name);for(int i=0; i<count; i++)if( !strcmp(num[i].name,name))Delete(num[i]);}else if(choose==3){printf("进程名\t\t开始地址\t\t大小\t\t结束地址\t\t\n");//输出内存信息for(int i=0; i<count-1; i++)for(int j=i; j<count-1; j++)if(num[j].start>num[j+1].start){a=num[j];num[j]=num[j+1];num[j+1]=a;}for(int i=0; i<count; i++)if(num[i].state!=0)printf("%s\t\t%d\t\t\t%d\t\t%d\t\t\n",num[i].name,num[i].start,num[i].size,num[i].s ize+num[i].start-1);}else if(choose==4){find_free_rom();show();}else break;}while(1);return 0;}首次适应算法：本实验共采用1024个内存进行模拟，首先对内存初始化，得到一个大的空闲区：相继插入3个进程：分别插入进程A B C,大小分别为100,200,300此时查询进程信息和查询空闲区信息有一块大小为424 起始地址为600的空闲区在进行插入D删除B此时有两块空闲区插入一个150大小的进程，他的起始地址应为100此时空闲区只有2块，一块大小为50，删除C进程，构造一块大空闲区再插入一个进程为100大小,此时两块空闲区都满足，此时应从第一块插入再插入一个大于两块空闲区大小的进程，此时无可用空间首次适应算法完成。