最佳适应算法流程图
最佳适应算法
0K 操作系统[100K]
分 配 前 存 储 器 示 意 图
100K 作业A[40K] 140K 45K
185K 195K 225K 245K
作业C[10K] 30K 作业D[20K] 作业E[20K]
分 配 前 存 储 器 示 意 图
已分配表 序号 首址 大小 状态 1 100K 40K 已分配 2 160K 10K 已分配 3 185K 10K 已分配 4 225K 20K 已分配 5 245K 20K 已分配 6 回收作业B前 序号 首址 大小 状态 1 100K 40K 已分配 2 160K 10K 空白 3 185K 10K 已分配 4 225K 20K 已分配 5 245K 20K 已分配 6 回收作业B后
0K 操作系统[100K] 100K 作业A[30K] 130K 20K 160K 作业B[10K] 170K 185K 195K 205K 15K 作业B[10K] 30K 作业C[20K] 作业D[20K]
分配算法
11 K 存 储 器 示 意 图
最 31 K 佳 适 回收算法 应 作业A 算 作业B 法
225K 20K 245K 20K
225K 20K 245K 20K
回收作业E前
回收作业E后
首次适应算法已分配区变化示意图
未分配表 序号 1 2 3 4 5 6 首址 140K 170K 195K 大小 20K 15K 30K 状态 未分配 未分配 未分配 序号 1 2 3 4 5 6 首址 170K 140K 245K 195K 大小 状态 15K 未分配 20K 未分配 20K 未分配 30K 未分配
已分配表 序号 首址 大小 状态 1 100K 40K 已分配 2 160K 10K 已分配 3 185K 10K 已分配 4 225K 20K 已分配 5 245K 20K 已分配 6 分配前 序号 首址 大小 状态 1 100K 40K 已分配 2 160K 10K 已分配 3 185K 10K 已分配 4 225K 20K 已分配 5 245K 20K 已分配 6 170K 11K 已分配 分配后
操作系统实验_最佳适应算法最坏适应算法
学号专业计算机科学与技术姓名实验日期2017/11/23教师签字成绩实验报告【实验名称】基于顺序搜索的动态分区分配算法(二)【实验目的】理解在连续分区动态的存储管理方式下，如何实现贮存空间的分配与回收。
采用可变式分区管理，使用最佳适应算法实现主存空间的分配与回收。
采用可变式分区管理，使用最坏适应算法实现主存空间的分配与回收。
【实验原理】C++语言程序设计数据结构最佳适应算法最坏适应算法数据结构和符号说明1、boolROM[N];//定义主存信息，如果内存被占用，则标记为1，否则标记为0，设置内存单元为10242、pcbnum[20];//定义作业数组，最大支持20个作业3、typedefstructPcb//定义作业结构体，包括名称，开始时间，大小，是否执行状态{charname[10];intstart;intsize;intstate=0;}pcb;主要函数：voidfind_free_rom()；//寻找空闲区voidsort1()；//对空闲区进行排序从小到大voidsort1()；//对空闲区进行排序从大到小voidshow()；//显示函数voidinsert_pcb1(pcb&a)；//最佳适应算法voidinsert_pcb2(pcb&a)；//最坏适应算法voidinit();//初始化函数算法流程图：最佳适应算法：最坏适应算法：#include<stdio.h>#include<string.h>#defineN1024boolROM[N];intp=0;intcount=0;intfree_rom_counter=0;//空闲区数目typedefstructPcb//进程结构体{charname[10];intstart;intsize;//大小intstate=0;//状态}pcb;pcbnum[20];//进程数组typedefstructFree_rom//空闲区结构体{intnum;intstart;intend;intspace;//空闲区大小}Free_room;Free_romfree_rom[100];//空闲区数组voidshow()//显示空闲区信息{printf("****************************************************************\n\n" );printf("空闲区名\t开始地址\t\t大小\t\t结束地址\t\t\n");for(inti=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);printf("\n");printf("****************************************************************\n\n" );}voidfind_free_rom()//寻找空闲区，更新空闲区数组{free_rom_counter=0;inti,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;}}}voidsort1()//最佳适应算法对空闲区从小到大排序{find_free_rom();Free_roma;for(inti=1;i<free_rom_counter;i++)for(intj=1;j<free_rom_counter;j++)if(free_rom[j].space>free_rom[j+1].space){a=free_rom[j];free_rom[j]=free_rom[j+1];free_rom[j+1]=a;}}voidsort2()//最坏适应算法对空闲区从大到小排序{find_free_rom();Free_roma;for(inti=1;i<free_rom_counter;i++)for(intj=1;j<free_rom_counter;j++)if(free_rom[j].space<free_rom[j+1].space){a=free_rom[j];free_rom[j]=free_rom[j+1];free_rom[j+1]=a;}}voidinit()//初始化{for(inti=0;i<N;i++)ROM[i]=0;}voidinput(pcb&a)//输入{charname[10];printf("输入进程名\n");scanf("%s",&);printf("输入进程大小\n");scanf("%d",&a.size);}voidinsert_pcb1(pcb&a)//最佳适应算法插入进程{find_free_rom();sort1();inti,j,k;for(i=1;i<=free_rom_counter;i++)//判断插入if(a.size<=free_rom[i].space){for(j=free_rom[i].start;j<free_rom[i].start+a.size;j++) ROM[j]=1;a.state=1;a.start=free_rom[i].start;num[count++]=a;break;}if(i==free_rom_counter+1)//插入失败printf("可用空间不足!\n");}voidinsert_pcb2(pcb&a)//最坏适应算法插入{find_free_rom();sort2();inti,j,k;for(i=1;i<=free_rom_counter;i++)if(a.size<=free_rom[i].space){for(j=free_rom[i].start;j<free_rom[i].start+a.size;j++)//寻找ROM[j]=1;a.state=1;a.start=free_rom[i].start;num[count++]=a;break;}if(i==free_rom_counter+1)//插入失败printf("可用空间不足!\n");}voidDelete(pcb&a)//内存中释放进程{inti;for(i=a.start;i<a.start+a.size;i++)ROM[i]=0;//更新内存信息，更新进程状态数组a.state=0;printf("删除成功\n");find_free_rom();}intmain()//主函数{init();find_free_rom();intchoose1;intchoose;charname[10];printf("1、最佳适应算法\n");//主界面printf("2、最坏首次适应算法\n");scanf("%d",&choose1);pcba;do{printf("\n\n1、插入进程\n");printf("2、删除进程\n");printf("3、显示进程信息\n");printf("4、显示空余内存信息\n");scanf("%d",&choose);if(choose==1)//选择{input(a);if(choose1==1)insert_pcb1(a);elseinsert_pcb2(a);}elseif(choose==2){printf("输入删除进程的名字\n");scanf("%s",&name);for(inti=0;i<count;i++)if(!strcmp(num[i].name,name))Delete(num[i]);}elseif(choose==3){printf("****************************************************************\n\n" );printf("进程名\t\t开始地址\t\t大小\t\t结束地址\t\t\n");//输出内存信息for(inti=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,nu m[i].size+num[i].start-1);printf("\n****************************************************************\n\ n");}elseif(choose=4){find_free_rom();show();}elsebreak;}while(1);return0;}截图：构造如下空闲区：此时插入一个进程G，大小为80H，应插入到第二块空闲区再插入一个大小为30的进程H，应插入到第三块中再插入一个小进程，大小为5，插入到第二块空闲区，查看进程信息和空闲区信息：最佳适应算法成立。
动态分区分配算法描述
动态分区分配算法描述一、引入动态分区分配算法：在动态分区分配方式中，当很多个空闲分区都能满足需求时，应该选择哪个分区进行分配？二、首次适应算法（First Fit）算法思想：每次都从低地址开始查找，找到第一个能满足大小的空闲分区。
如何实现：空闲分区以地址递增的次序排列。
每次分配内存时顺序查找空闲分区链（或空闲分区表），找到大小能满足要求的第一个空闲分区。
三、最佳适应算法（Best Fit）算法思想：由于动态分区分配是一种连续分配方式，为各进程分配的空间必须是连续的一整片区域。
因此为了保证当“大进程”到来时能有连续的大片空间，可以尽可能多地留下大片的空闲区，即优先使用更小的空闲区。
如何实现：空闲分区按容量递增次序链接。
每次分配内存时顺序查找空闲分区链（或空闲分区表），找到大小能满足要求的第一个空闲分区。
缺点：每次都选最小的分区进行分配，会留下越来越多的、很小的、难以利用的内存块。
因此这种方法会产生很多的外部碎片。
四、最坏适应算法(Worst Fit)又称最大适应算法（Largest Fit）算法思想：为了解决最佳适应算法的问题——即留下太多难以利用的小碎片，可以在每次分配时优先使用最大的连续空闲区，这样分配后剩余的空闲区就不会太小，更方便使用。
如何实现：空闲分区按容量递减次序链接。
每次分配内存时顺序查找空闲分区链（或空闲分区表），找到大小能满足要求的第一个空闲分区。
重新排序：空闲分区按容量递减次序链接缺点：每次都选最大的分区进行分配，虽然可以让分配后留下的空闲区更大，更可用，但是这种方式会导致较大的连续空闲区被迅速用完。
如果之后有“大进程”到达，就没有内存分区可用了。
五、邻近适应算法（Next Fit）算法思想：首次适应算法每次都从链头开始查找的。
这可能会导致低地址部分出现很多小的空闲分区，而每次分配查找时，都要经过这些分区，因此也增加了查找的开销。
如果每次都从上次查找结束的位置开始检索，就能解决上述问题。
第十一讲存储器管理之连续分配方式
第十一讲存储器管理之连续分配方式所谓连续分配方式：是指为一个用户程序分配一个连续的内存空间。
又可把连续分配方式分为：单一连续分配，固定分区分配，动态分区分配，动态重定位分区分配，四种方式。
1 单一连续分配（单独分区分配）最简单的一种存储管理方式，但只能用于单用户、单任务的OS中。
概念：单一连续分配就是整个主存区域的用户空间均归一个用户作业使用。
存储管理方法：将内存分为系统区（内存低端，分配给OS用）和用户区（内存高端，分配给用户用）。
其中用户区是指除了系统区外的内存空间，提供给用户程序使用。
采用静态分配方式，即作业一旦进入内存，就要等待它运行结束后才能释放内存。
主要特点：管理简单，只需小量的软件和硬件支持，便于用户了解和使用。
但因内存中只装入一道作业运行，内存空间浪费大，各类资源的利用率也不高。
例子：一个容量为256KB的内存，操作系统占用32KB，剩下224KB全部分配给用户作业，如果一个作业仅需64KB，那么就有160KB的存储空间被浪费。
2 固定分区分配分区分配方式是满足多道程序设计需要的一种最简单的存储管理方法。
2.1 思想：将内存分成若干个分区（大小相等/不相等），除OS占一区外，其余的每一个分区容纳一个用户程序。
这样来实现多道并发。
2.2 分区划分方法：分区大小相等，分区大小不等。
但事先必须确定，在运行时不能改变。
即分区大小及边界在运行时不能改变。
2.3 内存分配：首先：要先建立一张分区说明表或使用表，以记录分区号、分区大小、分区的起始地址及状态（已分配或未分配）。
其次：当某个用户程序要装入内存时，由内存分配程序检索分区说明表，从表中找出一个满足要求的尚未分配的分区分配该程序，同时修改说明表中相应分区的状态；若找不到大小足够的分区，则拒绝为该程序分配内存。
第三：当程序执行完毕，释放占用的分区，管理程序将修改说明表中相应分区的状态为未分配，实现内存资源的回收。
2.4 特点主要特点：管理简单，但因作业的大小并不一定与某个分区大小相等，从而使一部分存储空间被浪费。
首次适应算法和最佳适应算法【讲解】
首次适应算法和最佳适应算法是动态存储分配解决方案研究的内容，所以本文对这两种算法的讨论是通过研究动态存储管理来进行的。
一、存储管理的基本问题：存储管理讨论的基本问题是：1)、系统如何应用户的“请求”执行内存分配动作？2)、系统如何对用户不再使用后“释放”的内存执行回收动作，以保证为新的“用户请求”提供内存分配？内存的分配可以以静态方式进行，内存空间被分割为固定大小的若干内存块，用户的请求到达只要找到一块空闲的内存块予以分配即可，很显然静态存储分配的好处主要是实现比较方便，效率高，程序执行中系统需要做的事情比较简单。
然而实际情况下提出“请求”的用户可能是进入系统的一个作业，也可能是程序执行过程中的一个动态变量。
“请求”需要获得的内存容量大小不一，这种做法造成了对程序大小的严格的限制，使某些问题不能够合理的解决，此外，也会造成内存空间的浪费。
动态存储管理就是确定如何满足一个个内存“请求”，如何更合理的使用有限的内存空间的一种内存分配解决方案，它以能够依据用户的请求依次进行内存空间的分配和回收，能够尽可能少的使用有限的空闲内存空间，最大限度的保证后续“请求”的可满足性为最终目的。
二、关于动态分配方案的分析：通常我们将已分配给用户是用的一段连续的内存空间称为“占用块”，将未分配给任何用户的一段连续的内存空间称为“可利用空间块”或者“空闲块”，我们在这里的描述将使用“占用块”和“空闲块”这两个概念。
整个内存区在没有任何用户进入和运行的情况下只有一个空闲块，即整个可供用户“请求”使用的用户内存区域。
随着不断的有用户请求进入系统，并依次获得系统为其分配的内存，使得整个内存区域逐渐被分割成两大部分：低地址区域包含若干占用块；高低址区域是空闲内存区域。
经过一段时间后，有的用户运行结束，它们所占用的内存区释放后转变为一个个空闲块，这就使整个内存区域呈现出占用块和空闲块交错相隔的状态。
而此时，如果再有新的用户“请求”到达，那么，系统如何为这个“请求”进行内存分配呢？在肯定动态存储管理的前提下，我们可以采取两种方案解决这个问题，一种解决方案是系统继续把高地址的空闲块分配给用户，而不理会低地址区域是否有结束执行的用户释放的内存块，直到剩余的高地址区域的空闲块不能满足新的用户“请求”，分配操作无法再进行下去时，才去回收结束执行的用户释放的内存块，并重新组织内存，进而完成内存分配。
内存管理中一些算法
内存管理中⼀些算法在内存管理中存在这两类算法：⼀类是内存分配算法，⼀类是页⾯置换算法内存分配算法：是指怎么从连续的逻辑地址空间上分配内存地址给进程。
常见内存分配算法及优缺点如下： （1）⾸次适应算法。
使⽤该算法进⾏内存分配时，从空闲分区链⾸开始查找，直⾄找到⼀个能满⾜其⼤⼩要求的空闲分区为⽌。
然后再按照作业的⼤⼩，从该分区中划出⼀块内存分配给请求者，余下的空闲分区仍留在空闲分区链中。
该算法倾向于使⽤内存中低地址部分的空闲分区，在⾼地址部分的空闲分区很少被利⽤，从⽽保留了⾼地址部分的⼤空闲区。
显然为以后到达的⼤作业分配⼤的内存空间创造了条件。
缺点在于低址部分不断被划分，留下许多难以利⽤、很⼩的空闲区，⽽每次查找⼜都从低址部分开始，这⽆疑会增加查找的开销。
（2）循环⾸次适应算法。
该算法是由⾸次适应算法演变⽽成的。
在为进程分配内存空间时，不再每次从链⾸开始查找，⽽是从上次找到的空闲分区开始查找，直⾄找到⼀个能满⾜要求的空闲分区，并从中划出⼀块来分给作业。
该算法能使空闲中的内存分区分布得更加均匀，但将会缺乏⼤的空闲分区。
（3）最佳适应算法。
该算法总是把既能满⾜要求，⼜是最⼩的空闲分区分配给作业。
为了加速查找，该算法要求将所有的空闲区按其⼤⼩排序后，以递增顺序形成⼀个空⽩链。
这样每次找到的第⼀个满⾜要求的空闲区，必然是最优的。
孤⽴地看，该算法似乎是最优的，但事实上并不⼀定。
因为每次分配后剩余的空间⼀定是最⼩的，在存储器中将留下许多难以利⽤的⼩空闲区。
同时每次分配后必须重新排序，这也带来了⼀定的开销。
（4）最差适应算法。
最差适应算法中，该算法按⼤⼩递减的顺序形成空闲区链，分配时直接从空闲区链的第⼀个空闲分区中分配（不能满⾜需要则不分配）。
很显然，如果第⼀个空闲分区不能满⾜，那么再没有空闲分区能满⾜需要。
这种分配⽅法初看起来不太合理，但它也有很强的直观吸引⼒：在⼤空闲区中放⼊程序后，剩下的空闲区常常也很⼤，于是还能装下⼀个较⼤的新程序。
操作系统 首次最佳适应算法
学号专业姓名实验日期教师签字成绩实验报告【实验名称】采用可变式分区管理，使用首次获最佳适应算法实现内存分配与回收【实验目的与原理】1、理解首次获最佳适应算法的内涵，并熟练掌握该算法。
2、学会可变式分区管理的原理是即在处理作业过程中建立分区，使分区大小正好适合作业的需要，并且分区个数是可以调整的。
3、当有一个新作业要求装入主存时，必须查空闲区说明表，从中找出一个足够大的空闲区没有时应将空闲区一分为二。
为了便于快速查找，要不断地对表格进行紧缩，即让“空表目”项留在表的后部。
4、当一个作业执行完成时，作业所占用的分区应归还给系统。
作业的释放区与空闲区的邻接分以下四种情况考虑：①释放区下邻（低地址邻接）空闲区；②释放区上邻（高地址邻接）空闲区③释放区上下都与空闲区邻接；④释放区与空闲区不邻接。
【实验内容】#include<stdio.h>#include<iostream>#include<string>using namespace std;const int MAXJOB=100;//定义表最大记录数typedef struct node{int front;int length;char data[20];}job;job frees[MAXJOB];//定义空闲区表int free_quantity;job occupys[MAXJOB];//定义已分配区表int occupy_quantity;//初始化函数void initial(){int i;for(i=0;i<MAXJOB;i++){frees[i].front=-1;frees[i].length=0;strcpy(frees[i].data,"free");occupys[i].front=-1;occupys[i].length=0;strcpy(occupys[i].data," ");}free_quantity=0;occupy_quantity=0;}//创建空闲分区表int creatfree(){FILE *fp;char fname[20];cout<<"请输入空闲区数据文件来源的文件名:"; cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl; }else{while(!feof(fp)){fscanf(fp,"%d\t%d\n",&frees[free_quanti ty].front,&frees[free_quantity].length);free_quantity++;}cout<<"空闲的分区表已建立！\n";return 1;}return 0;}void sort()//将free空间安首地址从小到大的顺序排列{int i,j,p;for(i=0;i<free_quantity-1;i++){p=i;for(j=i+1;j<free_quantity;j++){if(frees[j].front<frees[p].front){p=j;}}if(p!=i){frees[free_quantity]=frees[i];frees[i]=frees[p];frees[p]=frees[free_quantity];}}}//显示函数void show(){int i;cout<<endl<<"----------------------------------------------------------"<<endl;cout<<"当前空闲表:"<<endl;cout<<" 起始地址长度状态"<<endl;for(i=0;i<free_quantity;i++){cout.setf(2);cout.width(12);cout<<frees[i].front;cout.width(10);cout<<frees[i].length;cout.width(8);cout<<frees[i].data<<endl;}cout<<endl<<"----------------------------------------------------------"<<endl;cout<<"当前已分配表:"<<endl;cout<<" 起始地址长度占用作业名"<<endl;for(i=0;i<occupy_quantity;i++){cout.setf(2);cout.width(12);cout<<occupys[i].front;cout.width(10);cout<<occupys[i].length;cout.width(8);cout<<occupys[i].data<<endl;}cout<<endl<<"----------------------------------------------------------"<<endl;}//最先适应分配算法void assign(){char job_name[20];int job_length;int i,j,flag,t;cout<<"请输入新申请内存空间的作业名和空间大小:";cin>>job_name;cin>>job_length;flag=0;for(i=0;i<free_quantity;i++){if(frees[i].length>=job_length)//如果空闲空间I的长度〉作业长度{flag=1; //空闲标志位就置1 }}if(flag==0){cout<<endl<<"对不起,当前没有能满足你申请长度的空闲内存,请稍候再试！"<<endl;}else{t=0;i=0;while(t==0)//为空闲区间的时候{if(frees[i].length>=job_length){t=1;}i++;//如果空闲空间I的长度不大于作业长度，I加一，判断下一个空间}i--;occupys[occupy_quantity].front=frees[i] .front;strcpy(occupys[occupy_quantity].data,jo b_name);occupys[occupy_quantity].length=job_len gth;occupy_quantity++;if(frees[i].length>job_length)//如果空间的长度大于作业的长度，{frees[i].front+=job_length;frees[i].length-=job_length;}else{for(j=i;j<free_quantity-1;j++){frees[j]=frees[j+1];}free_quantity--;cout<<"内存空间成功:)"<<endl;}}}//撤消作业void cancel(){char job_name[20];int i,j,flag,p=0;int front;int length;cout<<"请输入要撤消的作业名:";cin>>job_name;flag=-1;for(i=0;i<occupy_quantity;i++){if(!strcmp(occupys[i].data,job_name))//当输入作业名匹配时{flag=i;front=occupys[i].front;length=occupys[i].length;}}if(flag==-1){cout<<"没有这个作业名"<<endl;}else{//加入空闲表for(i=0;i<free_quantity;i++){if((frees[i].front+frees[i].length)==fr ont)//上空{if(((i+1)<free_quantity)&&(frees[i+1].f ront==front+length))//下空{frees[i].length=frees[i].length+frees[i +1].length+length;for(j=i+1;j<free_quantity;j++){frees[j]=frees[j+1];}free_quantity--;p=1;}else{frees[i].length+=length;p=1;}}if(frees[i].front==(front+length))//下空上不空{frees[i].front=front;frees[i].length+=length;//第i 个空闲区间的长度=第i个空闲区间的长度+lengthp=1;}}if(p==0)//上下空闲区都不空{frees[free_quantity].front=front;frees[free_quantity].length=length;free_quantity++;}//删除分配表中的该作业for(i=flag;i<occupy_quantity;i++){occupys[i]=occupys[i+1];}occupy_quantity--;}}void main(){int flag=0;int t=1;int chioce=0;cout<<"*********** xxxxxxxxx***********\n"; initial();flag=creatfree();while(flag==1){sort();cout<<" 可变分区存储管理模拟系统"<<endl;cout<<" 1.申请空间 "<<endl;cout<<" 2.撤消作业 "<<endl;cout<<" 3.显示空闲表和分配表"<<endl;cout<<" 0.退出"<<endl;cout<<"请选择:";cin>>chioce;switch(chioce){case 1:assign();break;case 2:cancel();break;case 3:show();break;case 0:flag=0;break;default:cout<<"选择错误!"<<endl;}}}实验结果显示：【实验小结】本实验难度在两个方面，一是首次最佳适应算法assign()，这里我用的是结构体数组来存储空闲分区；二是对已分配分区的释放，这里同样采取结构体数组来存储已分配分区，用cancle（）函数来实现。
存储管理首次、最佳、最坏适应算法
最佳适应算法最佳适应算法是从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区的一种计算方法，这种方法能使碎片尽量小。
找到：满足要求的自由分区分配排序：从小到大含义最佳适应算法（Best Fit）：它从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区，这种方法能使碎片尽量小。
为适应此算法，空闲分区表（空闲区链）中的空闲分区要按从小到大进行排序，自表头开始查找到第一个满足要求的自由分区分配。
该算法保留大的空闲区，但造成许多小的空闲区。
应用问题Best fit算法等价于装箱问题，举例如下：装箱问题：有体积为V的箱子N个，体积为Vi的物品M个，求使得物品全部能够装入箱子，箱子数量的最小值。
假设 V=6 M=10，V1，V2，...,V10分别为：3 4 4 3 5 1 2 5 3 1。
计算过程如下：第一步按物品体积降序排序：5 5 4 4 3 3 3 2 1 1第二步：取未装箱的最大值5装入第一个箱子。
第三步：判断第一个箱子是否已满，不满且剩余空间为1，搜寻剩下体积小于等于1的物品填入箱子1，箱子1填满。
第四步：重复第二，第三步，直到所有物品装入箱子为止，得到箱子数量为6. 6即时本例N的最小值。
最坏适应算法特点：扫描整个空闲分区或链表优点：可使剩下的空闲分区不至于太小最坏适应算法(worst fit)最坏适应分配算法要扫描整个空闲分区或链表，总是挑选一个最大的空闲分区分割给作业使用。
该算法要求将所有的空闲分区按其容量从大到小的顺序形成一空闲分区链，查找时只要看第一个分区能否满足作业要求。
优点:可使剩下的空闲分区不至于太小，产生碎片的几率最小，对中、小作业有利，同时该算法查找效率很高。
缺点:会使存储器中缺乏大的空闲分区。
首次适应算法首次适应算法从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法目的在于减少查找时间。
为适应这种算法，空闲分区表(空闲区链)中的空闲分区要按地址由低到高进行排序。
算法和流程图（及N-S流程图）
算法和流程图（及N-S流程图）算法和流程图2.1.1算法计算机语⾔只是⼀种⼯具。
光学习语⾔的规则还不够，最重要的是学会针对各种类型的问题，拟定出有效的解决⽅法和步骤即算法。
有了正确⽽有效的算法，可以利⽤任何⼀种计算机⾼级语⾔编写程序，使计算机进⾏⼯作。
因此，设计算法是程序设计的核⼼。
并⾮只有“计算”的问题才有算法。
⼴义地说，为解决⼀个问题⽽采取的⽅法和步骤，称为“算法”。
不要把“计算⽅法”（computational method）和“算法”（algorithm）这两个词混淆。
前者指的是求数值解的近似⽅法，后者是指解决问题的⼀步⼀步的过程。
在解⼀个数值计算问题时，除了要选择合适的计算⽅法外，还要根据这个计算⽅法写出如何让计算机⼀步⼀步执⾏以求解的算法。
对于计算机外⾏来说，他们可以只使⽤别⼈已设计好的现成算法，只需根据算法的要求给以必要的输⼊，就能得到输出的结果。
对他们来说，算法如同⼀个“⿊箱⼦”⼀样，他们可以不了解“⿊箱⼦”中的结构，只是从外部特性上了解算法的作⽤，即可⽅便地使⽤算法。
但对于程序设计⼈员来说，必须会设计算法，并且根据算法编写程序。
对同⼀个问题，可以有不同的解题⽅法和步骤。
例如，求1+2+3+…+100，可以先进⾏1+2，再加3，再加4，⼀直加到100，也可采取100+ (1+99)+(2+98)+…+(49+51)+50＝100+50+49×100＝5050。
还可以有其它的⽅法。
当然，⽅法有优劣之分。
有的⽅法只需进⾏很少的步骤，⽽有些⽅法则需要较多的步骤。
⼀般说，希望采⽤⽅法简单，运算步骤少的⽅法。
因此，为了有效地进⾏解题，不仅需要保证算法正确，还要考虑算法的质量，选择合适的算法。
⼀个计算问题的解决过程通常包含下⾯⼏步:确⽴所需解决的问题以及最后应达到的要求。
必须保证在任务⼀开始就对它有详细⽽确切的了解，避免模棱两可和含混不清之处。
分析问题构造模型。
在得到⼀个基本的物理模型后，⽤数学语⾔描述它，例如列出解题的数学公式或联⽴⽅程式，即建⽴数学模型。
操作系统实验_最佳适应算法最坏适应算法
操作系统实验_最佳适应算法最坏适应算法最佳适应算法和最坏适应算法都是操作系统中用于内存分配的算法之一、它们的目的都是为了更高效地利用系统内存资源，减少碎片化和提高内存的使用率。
以下将分别介绍这两种算法的原理和优缺点。
最佳适应算法（Best Fit Algorithm）是指在内存分配时，选择最小且能够容纳作业的空闲分区，以便尽量高效地利用内存空间。
具体步骤如下：1.遍历所有空闲分区，找到大小最小且能容纳作业的空闲分区。
2.如果找到了符合条件的空闲分区，则将作业放入该分区。
3.如果找不到符合条件的空闲分区，则申请新的内存分区，并将作业放入该分区。
最佳适应算法的优点是能够充分利用内存资源，最大程度地减少碎片化。
它适用于空闲分区大小随机、数量较少的情况。
然而，该算法的缺点是比较复杂，需要遍历所有空闲分区才能找到合适的分区，这会增加分配的时间开销。
最坏适应算法（Worst Fit Algorithm）是指在内存分配时，选择最大的空闲分区，并将作业放入该分区。
具体步骤如下：1.遍历所有空闲分区，找到大小最大的空闲分区。
2.如果找到了符合条件的空闲分区，则将作业放入该分区。
3.如果找不到符合条件的空闲分区，则申请新的内存分区，并将作业放入该分区。
最坏适应算法的优点是简单，实现较为容易。
它适用于情况较为固定，空闲分区大小较大时。
然而，该算法的缺点是会产生大量内部碎片，导致内存利用率下降。
最佳适应算法和最坏适应算法在实际应用中需要根据具体情况进行选择。
当空闲分区大小差异较大时，最坏适应算法可以使得分配的作业尽可能少地分割分区。
然而，在空闲分区大小相近的情况下，最坏适应算法可能导致较多的外部碎片，并且分区利用率较低。
相比之下，最佳适应算法则可以更好地利用内存资源，但在分配过程中可能需要更多的时间和计算开销。
综上所述，最佳适应算法和最坏适应算法都有各自的优缺点，适用于不同的场景。
在实际操作中，需要根据具体情况选择合适的算法，以达到最优的内存管理效果。
广工 操作系统课程设计 最佳适应算法、最坏适应算法、循环首次适应算法
动态分区分配算法仿真，循环首次适应算法、最佳适应算法、最坏适应算法#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一样时，由于先按地址递增排序了，所以还是地址低的在前。
可变分区分配与回收——采用最坏算法-操作系统课程设计
哈尔滨理工大学课程设计（操作系统）题目：可变分区分配与回收—采用最坏算法班级：计算机科学与技术学院计算机系10-8班姓名：张兢 1004010813指导教师：高雪瑶系主任：林克正2013年03月01日一、课程设计目的1、背景主存是CPU可直接访问的信息空间，合理而有效的使用贮存将在很大程度上影响整个计算机系统的性能。
本课题要求模拟实现分区式主存管理机制。
模拟实现各种分区管理方法以及相应的主存分配以及回收算法。
2、目的通过该课题进一步加深对可变分区存储机制的理解。
加深对存储器动态分区分配算法的认识。
掌握“首次适应算法”、“下次适应算法”、“最佳适应算法发”、“最坏适应算法”的内存分配过程。
掌握内存的回收策略。
二、课题任务描述1、设计可用的内存空闲空间，并能动态输入用户作业所需的内存大小。
2、编程模拟各种分配算法的实施过程，允许自行选择如“首次适应算法”、“下次适应算法”、“最佳适应算法发”、“最坏适应算法”等常用算法，要求实现不少于三种算法。
3、实现内存的回收。
要求考虑回收时的内存合并问题。
三、课题研发相关知识（包含所用库函数的介绍）1、首次适应算法（first fit）FF算法要求空闲分区链以地址递增的次序链接。
在分配内存时，从链首开始顺序查找，直至找到一个大小能男足要求的空闲分区位置；然后再按照作业的大小，从该分区中划出一块内存空间分配给请求者，余下的空闲分区仍留在空闲链中。
若从链首直至链尾都不能找到一个能满足要求的分区，则此次内存分配失败，返回。
但是，低址部分不断被划分，会留下许多难以利用的很小的空闲分区。
2、最佳适应算法（best fit）所谓“最佳”是指每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业，避免“大材小用”。
为了加速寻找，该算法要求将所有的空闲分区按其容量以从小到大的顺序形成一空闲分区链。
这样，第一次找到的能满足要求的空闲区，必然是最佳的。
这样，在存储器中会留下许多难以利用的小空闲区。
可变分区存储管理的内存分配算法模拟实现----最佳适应算法 -回复
可变分区存储管理的内存分配算法模拟实现----最佳适应算法-回复可变分区存储管理是一种内存管理技术，其通过将内存分割成不同大小的区域来存储进程。
每个进程被分配到与其大小最匹配的区域中。
内存分配算法的选择影响了系统的性能和资源利用率。
本文将介绍最佳适应算法，并模拟实现该算法。
一、什么是最佳适应算法？最佳适应算法是一种可变分区存储管理中的内存分配策略。
它的基本思想是在每次内存分配时选择最合适的空闲区域。
具体来说，它从可用的空闲区域中选择大小与需要分配给进程的内存最接近的区域。
二、算法实现思路最佳适应算法实现的关键是如何快速找到最合适的空闲区域。
下面给出一个模拟实现的思路：1. 初始化内存分区列表，首先将整个内存定义为一个大的空闲区域。
2. 当一个进程请求分配内存时，从列表中找到与所需内存最接近的空闲区域。
3. 将该空闲区域分割成两部分，一部分分配给进程，并将该部分标记为已分配，另一部分留作新的空闲区域。
4. 更新内存分区列表。
5. 当一个进程释放内存时，将其所占用的内存区域标记为空闲，然后尝试合并相邻的空闲区域。
三、算法模拟实现下面是一个简单的Python代码实现最佳适应算法：pythonclass MemoryPartition:def __init__(self, start_addr, end_addr, is_allocated=False): self.start_addr = start_addrself.end_addr = end_addrself.is_allocated = is_allocatedclass MemoryManager:def __init__(self, total_memory):self.total_memory = total_memoryself.partition_list = [MemoryPartition(0, total_memory)]def allocate_memory(self, process_size):best_fit_partition = Nonesmallest_size = float('inf')# 找到最佳适应的空闲区域for partition in self.partition_list:if not partition.is_allocated and partition.end_addr - partition.start_addr >= process_size:if partition.end_addr - partition.start_addr < smallest_size:best_fit_partition = partitionsmallest_size = partition.end_addr - partition.start_addrif best_fit_partition:# 将空闲区域分割，并标记为已分配new_partition =MemoryPartition(best_fit_partition.start_addr,best_fit_partition.start_addr + process_size, True)best_fit_partition.start_addr += process_sizeself.partition_list.append(new_partition)return new_partition.start_addr,new_partition.end_addrelse:return -1, -1def deallocate_memory(self, start_addr, end_addr):for partition in self.partition_list:if partition.start_addr == end_addr and not partition.is_allocated:# 标记空闲区域partition.is_allocated = False# 尝试合并相邻空闲区域for next_partition in self.partition_list:if not next_partition.is_allocated andnext_partition.start_addr == end_addr:end_addr = next_partition.end_addrself.partition_list.remove(next_partition)breakelse:breakdef print_partitions(self):for partition in self.partition_list:if partition.is_allocated:print(f"Allocated Partition: {partition.start_addr} - {partition.end_addr}")else:print(f"Free Partition: {partition.start_addr} - {partition.end_addr}")# 测试最佳适应算法if __name__ == "__main__":mm = MemoryManager(1024)start, end = mm.allocate_memory(256)print(f"Allocated memory: {start} - {end}")mm.print_partitions()mm.deallocate_memory(start, end)print("Memory deallocated:")mm.print_partitions()以上代码实现了一个简单的内存管理器类`MemoryManager`，它具有`allocate_memory`和`deallocate_memory`等方法。
存储管理部分题目
存储管理部分题目存储管理部分练习题一、选择题：1、把作业地址空间中使用的逻辑地址变成内存中的物理地址称为。
A、加载B、重定位C、物理化D、逻辑化2、虚存的基础是，其基本含义是。
A、局部性理论B、代码的顺序执行C、程序执行时对内存访问不均匀D、变量的连续访问E、指令局部性 3、某系统采用基址、限长寄存器保护方法实现存储保护，在这种方法中判断是否越界的判别式为。
A、0≤被访问的物理地址＜基址寄存器的内容 B、0≤被访问的物理地址≤寄存器的内容 C、0≤被访问的逻辑地址＜限长寄存器的内容 D、0≤被访问的逻辑地址≤限长寄存器的内容 4、最佳适应算法的空白区是。
A、按大小递增顺序排列的 B、按大小递减顺序排列的 C、按地址小到大排列的 D、按地址有大到小排列的 5、在页式存储管理中，每当CPU形成一个有效地址(虚地址)时，要查页表，这一工作是实现的，操作系统感知页表的存在。
A、硬件自动B、操作系统C、查表程序 D、存取控制程序 E、能够F、不能够 6、具有虚拟存储功能的管理方法包括。
A、可变分区存储管理 B、页式存储管理 C、段式存储管理D、段页式存储管理7、采用不会产生内部碎片。
A、分页式存储管理 B、分段式存储管理 C、固定分区式存储管理 D、段页式存储管理8、测得某个采用按需调页(Demand-Paging)策略的计算机系统部分状态数据为：CPU利用率20%，用于对换空间的硬盘的利用率%，其他设备的利用率5%，此断定系统出现异常。
此种情况下，能提高利用率。
A、安装一个更快的硬盘B、通过扩大硬盘容量，增加对换空间C、增加运行进程数D、加内存条，增加物理空间容量二、填空题：1、为了支持多道程序运行，存储管理的主要功能应该是、、。
2、虚拟存储器的最大容量是决定的。
3、在可变分区存储管理中，分区的保护通常采用和两种方式。
4、在分区分配算法中，首次适应算法倾向于优先利用内存中部分的空闲分区，从而把保留了部分的大空闲区。
首次适应算法和最佳适应算法-C++语言版
#iiiclude<iostieam>#iiiclude<stdlib.h> using namespace std;#define Free 0 〃空闲状态#define Busy 1 〃已用状态#define OK 1 〃完成#define ERROR。
〃出错#define MAXJength 512 //最大内存空间为512KB typedef int Status; hit flag;typedef stnict fieeaiea//定义一个空闲区说明表结构{long size; 〃分区大小long adckess; 〃分区地址mt state; 〃状态JElemType;//线性表的双向链表存储结构typedef stnict DuLNode{ElemType data;stiuct DuLNode *prior; 〃前趋指针stnict DuLNode *next; 〃后继指针}DuLNode,*DuLinkList;DuLnikList block_fkst; 〃头结点DuLnikList blockjast; 〃尾结点Status alloc(int);//内存分配Status See(int); 〃内存回收Status Fust_fit(iiit);//W 次适应算法Status Best_fit(mt); 〃最佳适应算法void show。
;〃查看分配Status InitblockO；〃开创空间表Status Irntblock。
〃开创带头结点的内存空间链表 {block_fust=(DuLinkList)malloc(sizeof(DuLNode));block_last=(DuLinkList)malloc(sizeof(DuLNode));block_fiist->prioi-NULL;block_fiist->next=block_last; block_last->pnor=block_fiist;block_last->next=NULL;block_last->data.address=0;block_last->data.size=MAX」ength;block_last->data.state=Free;return OK;}〃分配主存Status alloc(mt ch) (hit request = 0;coutvv”请输入需要分配的主存大小(单位:KB)： "；ciii»request;ifi(request<0 ||request==O) (coutvv”分配大小不合适，请重试！”《endl;retuin ERROR:}if(ch==2 ”/选择最佳适应算法(if(Best_fit(iequest)=OK) coutw”分配成功！"<<endl; elsecout«H内存不足，分配失败！ "<<endl;return OK;}else 〃默认首次适应算法(if(Fiist_fit(request)==OK) coutw”分酉已成功！H«endl; elsecout«H内存不足，分配失败！ "<<endl;return OK;} }〃首次适应算法Status request)(〃为申请作业开辟新空间且初始化DuLnikList temp=(DuLnikList)malloc(sizeof(DuLNode));temp->data.size=request;temp->data.state=Busy;DuLNode *p=block_fiist->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->pnor;temp->next=p;temp->data.addiess=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(mt request) (mt ch; 〃记录最小剩余空间DuLnikList temp=(DuLnikList)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 ifi(q->data.size > p->data.size)q=p;ch=p->data.size-request;) p=p->next;}if(q=NULL) i-eturn ERROR;//没有找到空闲块else if(q->data.size==request)(q->data .state=Bu sy;return OK;} elsetemp->prior=q->pnor;temp->next=q;temp->data.address=q->data.addiess;q->pnor->next=temp;q->pnor=temp;q->data.addiess+=request;q->data.size=ch;return OK;}return OK;}〃主存回收Status fiee(int flag) (DuLNode *p=block_first;fbr(int i= 0; i <= flag; i++)if(p?=NULL)p=p->next;elsereturn ERROR:p->data .state=Free;if(p->pnor?=block_fust && p->prior->data.state=Free)//与前面的空闲块相连 ( p->pnor->data.size+=p->data.size;p->pnor->next=p->next;p->next->piioi-p->piior;p=p->piior;if(p->next!=block_last && p->next->data.state=Free)//与后面的空闲块相连 ( p->data.size+=p->next->data.size;p->next->next->prioi -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";DuLNode *p=block_first->next;coutw"分区号\t起始地址\t分区大小\t状态\n\iT;wliile(p)(cout«" M«flag++«M\t H;cout«M M«p->data.addiess«,l\t\t H;cout«M "«p->data.size«H KB\t\t n;if(p->data.state==Fiee) coutw”空闲WW”；else coutw” 已分配\n\n”；p=p->next;}cout〈v”++++++++++++++++++++++++++++++++++++++++++++++W\iT; }〃主函数hit(mt ch;//算法选择标记coutvv”请输入所使用的内存分配算法：证”；coutv V”( 1)首次适应算法\n(2)最佳适应算法\n” ；ciii»ch;while(ch<l ||ch>2)coutvv”输入错误，请重新输入所使用的内存分配算法：\1之cin»ch;}Imtblock(); 〃开创空间表mt choice; 〃操作选择标记wlule(l)(showQ;coutvv”请输入您的操作：”；cout«H\iil:申请内存\112:释放内存W0:退出\n"；cm»choice;if(choice==l) alloc(ch); // 申请内存else if(choice=2) // 释放回收mt flag;coutvv”请输入您要释放的分区号：”；cin»flag;fiee(flag);}else if(choice=0) break; //退出else//输入操作有误coutvv”输入有误，请重试！“<<endl;contmue;。
最佳适应算法流程图
将合并的或释放的分区按长度升序 重新插入到自由链表中。
结束
将后面所指分区按长度升序重新插入自由链表中直接分配p所指全部空间并摘除自由链表中所指分区结束开始释放分区与上空闲分区相邻释放分区与下空闲分区相邻结束释放分区与下空闲分区相邻摘除链表中上分区
最佳适应分配算法流程图:
开始
q=av ,p= av;
F p.len<X T q=p, p=p->next
T
p.len–X&g相邻
F
释放分区与下 空闲分区相邻
F
T
摘除链表中上下分 区。合并这三个分 区，将上空闲区长 度修改为三个分区 的长度。 摘除链表中上分 区。合并释放分区 与上分区，将上空 闲区长度修改为这 二分区的长度。 摘除链表中下分 区。合并释放分区 与下分区，将释放 分区中长度修改为 这二分区的长度。
F
将 p 指向的分区分割， 前面 p.len-X 大小的作为 自由分区，修改长度信 息，将之摘除。将后面 X 大小的分区进行分配 直接分配 p 所指全部空间， 并摘除自由链表中 p 所指 分区 将 p 所指分区按长度升 序重新插入自由链表中
结束
分区回收算法流程图:：
开始
T
释放分区与上 空闲分区相邻
最优适应分配算法
最优适应分配算法
分区分配算法(Partitioning Placement Algorithm) ，共有3种。
分别为最佳适应算法、首次适应算法、循环首次适应算法。
1、最佳适应算法（Best Fit）：
它从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区，这种方法能使碎片尽量小。
为适应此算法，空闲分区表（空闲区链）中的空闲分区要按大小从小到大进行排序，自表头开始查找到第一个满足要求的自由分区分配。
该算法保留大的空闲区，但造成许多小的空闲区。
2、首次适应算法（First Fit）：
从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法目的在于减少查找时间。
为适应这种算法，空闲分区表（空闲区链）中的空闲分区要按地址由低到高进行排序。
该算法优先使用低址部分空闲区，在低址空间造成许多小的空闲区，在高地址空间保留大的空闲区。
3、循环首次适应算法(Next Fit)：
该算法是首次适应算法的变种。
在分配内存空间时，不再每次从表头（链首）开始查找，而是从上次找到空闲区的下一个空闲开始查找，直到找到第一个能满足要求的的空闲区为止，并从中划出一块与请求大小相等的内存空间分配给作业。
该算法能使内存中的空闲区分布得较均匀。