首次适应算法,最佳适应算法,最坏适应算法源代码[宝典]
操作系统实验最佳适应算法最坏适应算法
学号P7*******专业计算机科学与技术姓名实验日期2017/11/23教师署名成绩实验报告【实验名称】鉴于次序搜寻的动向分划分派算法( 二 )【实验目的】理解在连续分区动向的储存管理方式下，怎样实现储存空间的分派与回收。
采纳可变式分区管理，使用最正确适应算法实现主存空间的分配与回收。
采纳可变式分区管理，使用最坏适应算法实现主存空间的分配与回收。
【实验原理】C++语言程序设计数据结构最正确适应算法最坏适应算法数据结构和符号说明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;主要函数：void find_free_rom()；//找寻安闲区void sort1()；//对安闲区进行排序从小到大void sort1()；//对安闲区进行排序从大到小void show()；//显示函数void insert_pcb1(pcb &a)；//最正确适应算法void insert_pcb2(pcb &a)；//最坏适应算法void init();//初始化函数算法流程图：最正确适应算法：开始安闲区登记安闲区表依据从小到大排序插入作业信息目前安闲区指针为第一块安闲区作业大小小于等于目前安闲区是插入目前作业改正安闲区登记，改正作业表持续插入是否输出相应信息否能否达大最后一个安闲区是否目前安闲区指针插入失败加一结束最坏适应算法：开始安闲区登记安闲区表依据从大到小排序插入作业信息目前安闲区指针为第一块安闲区作业大小小于等于目前安闲区是插入目前作业改正安闲区登记，改正作业表持续插入是否输出相应信息否能否达大最后一个安闲区是否目前安闲区指针加一插入失败结束#include<stdio.h>#include<string.h>#define N 1024bool ROM[N];int p=0;int count=0;int free_rom_counter=0;//安闲区数量typedef struct Pcb //进度结构体{char name[10];int start; intsize;//大小int state=0; //状态} pcb;pcb num[20];//进度数组typedef struct安闲区结构体Free_rom// {int num;int start;int end;int space;//安闲区大小} Free_room;Free_rom free_rom[100];//安闲区数组void show()//显示安闲区信息{printf("****************************************************************\n\n");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].s tart, free_rom[ i].space,free_rom[ i].end);printf("\n");printf("****************************************************************\n\n");}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 sort1()//最正确适应算法对安闲区从小到大排序{find_free_rom();Free_rom a;for(int i=1; i<free_rom_counter; i++)for(int j=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;}}void sort2()//最坏适应算法对安闲区从大到小排序{find_free_rom();Free_rom a;for(int i=1; i<free_rom_counter; i++)for(int j=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;}}void init()//初始化{for(int i=0; i<N; i++)ROM[i]=0;}void input(pcb输入&a)// {char name[10];printf("输入进度名 \n");scanf("%s",&);printf("输入进度大小 \n");scanf("%d",&a.size);}void insert_pcb1(pcb &a)//最正确适应算法插入进度{find_free_rom();sort1();int i,j,k;for(i=1; i<=free_rom_counter; i++)//判断插入if(a.size<= free_rom[i].space){for(j=free_rom[i].start;ROM[j]=1;a.state=1;a.start=free_rom[i].start;num[count++]=a;break;j<free_rom[i].start+a.size;j++) }if(i==free_rom_counter+1)// printf("可用空间不足插入失败!\n");}void insert_pcb2(pcb &a)//最坏适应算法插入find_free_rom();sort2();int i,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");}void Delete(pcb &a)//内存中开释进度{int i;for(i=a.start; i<a.start+a.size; i++)ROM[i]=0;// 更新内存信息，更新进度状态数组a.state=0;printf("删除成功 \n");find_free_rom();}int main()//主函数{init();find_free_rom();int choose1;int choose;char name[10];printf("1、最正确适应算法 \n");//主界面printf("2、最坏初次适应算法 \n");scanf("%d",&choose1);pcb a;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);else insert_pcb2(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("****************************************************************\n\n");printf("进程名 \t\t开始地址\t\t大小\t\t结束地点\t\t\n");//输出内存信息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].size+num[i].start-1);printf("\n****************************************************************\n\n");}else if(choose=4){find_free_rom();show();}else break;}while(1);return 0;}截图：结构以下安闲区：此时插入一个进度G，大小为80H，应插入到第二块安闲区再插入一个大小为30 的进度 H，应插入到第三块中再插入一个小进度，大小为5，插入到第二块安闲区，查察进度信息和安闲区信息：最正确适应算法建立。
循环首次适应算法、首次适应算法、最佳适应算法 C语言版
#include<stdio.h>#define getpch(type) (type*)malloc(sizeof(type))struct LNode{ int size;int start;int end;struct LNode *next;struct LNode *front;}*L; /*L为头指针*/typedef struct LNode LN;LN *find;int n;void InsertList(int size,int start){ // 在带头结点的单链线形表头结点后插入LN *p,*s,*t;p=L;t=p->next;s=getpch(LN); //生成新结点s->size=size;s->start=start;s->end=start + size ;s->next=t; //插入L中p->next=s;if(t) t->front=s;s->front=p;}//end of InsertListvoid PrintList() /*打印*/{LN *p; int i;p=L->next;printf("\n空闲区号长度起始位置终止位置\n");for(i=1;i<=n;i++){printf(" %3d\t %3d\t%3d\t %4d\n",i,p->size, p->start,p->end);p=p->next;}}void BFSortList() /*最佳适应算法的排序*/{LN *p,*s,*t;int min_size,i;int size,start,end;t=L->next;p=L->next;for(i=0;i<n;i++){s=p->next;min_size = p->size;while(s){if(min_size > s->size){min_size=s->size;t=s;}s=s->next;}size=t->size;start=t->start;end=t->end;t->size=p->size;t->start=p->start;t->end=p->end;p->size=size;p->start=start;p->end=end;t=p->next;p=p->next;}}// end of BF_SortListvoid SortList() /*首次和循环首次适应算法的排序*/ {LN *p,*s,*t;int min_start,i;int size,start,end;t=L->next;p=L->next;for(i=0;i<n;i++){s=p->next;min_start = p->start;while(s){if(min_start > s->start){min_start=s->start;t=s;}s=s->next;}size=t->size;start=t->start;end=t->end;t->size=p->size;t->start=p->start;t->end=p->end;p->size=size;p->start=start;p->end=end;t=p->next;p=p->next;}}// end of BF_SortListvoid GetFree() /*生成空闲分区链*/{int size,start,i;L=getpch(LN); /*生成一个表头结点*/ L->next=NULL;L->front=NULL;printf("请输入空闲区数:");scanf("%d",&n);for(i=1;i<=n;i++){printf("请输入第%2d空闲区的大小和始址:",i);scanf("%3d,%3d",&size,&start);InsertList(size,start);}printf("\n按任意键继续");//printf("\n空闲链表情况:\n");//PrintList();}// end of GetFreevoid Assign(int size) /*最佳适应算法和首次适应算法空闲分区的分配*/ {LN *p,*t;p=L->next;t=L;while(p){if(size > p->size){p=p->next;t=t->next;if(!p){printf("没有足够大的空闲区分配！分配不成功");}}else{p->size = p->size - size;p->start= p->start + size ;if(p->size==0){t->next = p->next ;p->next->front=t;n--;free(p);}printf("分配成功！\n");printf("分配后的空闲链表情况如下:\n");PrintList();break;}}}// end of FF_Assignint flag=-1;void NF_Assign(int size)/*循环首次适应算法的分配*/{LN *p,*t;int i=n;p=find->next;t=find;while(p){if(size > p->size){p=p->next;t=t->next;if(!p){printf("没有足够大的空闲区分配！分配不成功");}}else{p->size = p->size - size;p->start= p->start + size ;find=p;if(p->size==0){t->next = p->next;p->next->front=t;n--;free(p);}printf("分配成功！\n");flag=1;printf("分配后的空闲链表情况如下：\n");Print(L);break;}}if(flag==-1){ p=L->next;t=L;while(p!=find){if(size > p->size){p=p->next;t=t->next;if(!p){printf("没有足够大的空闲区分配！分配不成功");}else{p->size = p->size - size;p->start= p->start + size ;find=t;if(p->size==0){t->next = p->next ;p->next->front=t;n--;free(p);}printf("分配成功！\n");printf("分配后的空闲链表情况如下：");PrintList(L);break;}}}}// end of NF_Assignvoid Recover(int start, int end) /*回收*/{LN *p,*t;int size,flag=0;size=end-start;p=L->next;t=p->next;while(p){if(t && p->end==start && t->start==end)//回收区在两个空闲区中间{p->size = p->size + size + t->size;p->end = t->end;p->next=t->next;t->next->front=p;free(t);SortList(L);flag=1;break;}else if(p->end == start)//回收区在空闲区下方{flag=1;p->size = p->size + size;p->end = p->end + size ;SortList(L);break;}else if( p->start == end)//回收区在空闲区上方{p->size= p->size +size;p->start=start;SortList(L);flag=1;break;}p=p->next;if(p)t=p->next;}//回收区不与任何一个空闲区相邻if(flag==0){ InsertList(size,start); n++;}printf("回收后的空闲链表情况如下:");PrintList();printf("\n按任意键继续");}void main(){int start,end,size;int m;GetFree();getch();system("cls");/*清屏*/printf("请选择服务类型:\n");printf("\t1:首次适应算法\n");printf("\t2:循环首次适应算法\n");printf("\t3:最佳适应算法\n");printf("\t4:回收内存\n");printf("\t0:退出\n");printf("\t输入您要的选项:");scanf("%d",&m); if(m==2) find=L;while(m){switch(m){case 1: SortList(); printf("\n空闲链表情况:\n");PrintList();printf("请输入进程需要的空闲区大小:");scanf("%d",&size);Assign(size); printf("\n按任意键继续");break;case 2: SortList(); printf("\n空闲链表情况:\n");PrintList();printf("请输入进程需要的空闲区大小:");scanf("%d",&size);NF_Assign(size);printf("\n按任意键继续");break;case 3: BFSortList(); printf("\n空闲链表情况:\n");PrintList();printf("请输入进程需要的空闲区大小:");scanf("%d",&size);Assign(size);printf("\n按任意键继续");break;case 4: printf("请输入回收区的首地址和中止地址:");scanf("%3d,%3d",&start,&end);Recover(start,end);break;case 0: exit(0);default : printf("\n\t\t输入错误,请重新输入"); getch();}getch();system("cls");/*清屏*/printf("请选择服务类型:\n");printf("\t1:首次适应算法\n");printf("\t2:循环首次适应算法\n");printf("\t3:最佳适应算法\n");printf("\t4:回收内存\n");printf("\t0:退出\n");printf("\t输入您要的选项:");scanf("%d",&m);}}。
【免费下载】 循环首次适应算法、首次适应算法、最佳适应算法 C语言版
p->size=size; p->start=start; p->end=end;
t=p->next; p=p->next;
} }// end of BF_SortList
void SortList() /*首次和循环首次适应算法的排序*/ {
//PrintList(); }// end of GetFree
void Assign(int size) /*最佳适应算法和首次适应算法空闲分区的分配*/ {
LN *p,*t; p=L->next; t=L; while(p) {
if(size > p->size) {
p=p->next; t=t->next; if(!p) {
#include<stdio.h>
#define getpch(type) (type*)malloc(sizeof(type))
struct LNode
{ int size;
int start;
int end;
struct LNode *next;
struct LNode *front;
}*L; /*L 为头指针*/
对全部高中资料试卷电气设备，在安装过程中以及安装结束后进行高中资料试卷调整试验；通电检查所有设备高中资料电试力卷保相护互装作置用调与试相技互术关，系电，力根通保据过护生管高产线中工敷资艺设料高技试中术卷资，配料不置试仅技卷可术要以是求解指，决机对吊组电顶在气层进设配行备置继进不电行规保空范护载高与中带资负料荷试下卷高问总中题体资，配料而置试且时卷可，调保需控障要试各在验类最；管大对路限设习度备题内进到来行位确调。保整在机使管组其路高在敷中正设资常过料工程试况中卷下，安与要全过加，度强并工看且作护尽下关可都于能可管地以路缩正高小常中故工资障作料高；试中对卷资于连料继接试电管卷保口破护处坏进理范行高围整中，核资或对料者定试对值卷某，弯些审扁异核度常与固高校定中对盒资图位料纸置试，.卷保编工护写况层复进防杂行腐设自跨备动接与处地装理线置，弯高尤曲中其半资要径料避标试免高卷错等调误，试高要方中求案资技，料术编试交写5、卷底重电保。要气护管设设装线备备置敷4高、调动设中电试作技资气高，术料课中并3中试、件资且包卷管中料拒含试路调试绝线验敷试卷动槽方设技作、案技术，管以术来架及避等系免多统不项启必方动要式方高，案中为；资解对料决整试高套卷中启突语动然文过停电程机气中。课高因件中此中资，管料电壁试力薄卷高、电中接气资口设料不备试严进卷等行保问调护题试装，工置合作调理并试利且技用进术管行，线过要敷关求设运电技行力术高保。中护线资装缆料置敷试做设卷到原技准则术确：指灵在导活分。。线对对盒于于处调差，试动当过保不程护同中装电高置压中高回资中路料资交试料叉卷试时技卷，术调应问试采题技用，术金作是属为指隔调发板试电进人机行员一隔，变开需压处要器理在组；事在同前发一掌生线握内槽图部内 纸故，资障强料时电、，回设需路备要须制进同造行时厂外切家部断出电习具源题高高电中中源资资，料料线试试缆卷卷敷试切设验除完报从毕告而，与采要相用进关高行技中检术资查资料和料试检，卷测并主处且要理了保。解护现装场置设。备高中资料试卷布置情况与有关高中资料试卷电气系统接线等情况，然后根据规范与规程规定，制定设备调试高中资料试卷方案。
首次适应算法和最佳适应算法【讲解】
首次适应算法和最佳适应算法是动态存储分配解决方案研究的内容，所以本文对这两种算法的讨论是通过研究动态存储管理来进行的。
一、存储管理的基本问题：存储管理讨论的基本问题是：1)、系统如何应用户的“请求”执行内存分配动作？2)、系统如何对用户不再使用后“释放”的内存执行回收动作，以保证为新的“用户请求”提供内存分配？内存的分配可以以静态方式进行，内存空间被分割为固定大小的若干内存块，用户的请求到达只要找到一块空闲的内存块予以分配即可，很显然静态存储分配的好处主要是实现比较方便，效率高，程序执行中系统需要做的事情比较简单。
然而实际情况下提出“请求”的用户可能是进入系统的一个作业，也可能是程序执行过程中的一个动态变量。
“请求”需要获得的内存容量大小不一，这种做法造成了对程序大小的严格的限制，使某些问题不能够合理的解决，此外，也会造成内存空间的浪费。
动态存储管理就是确定如何满足一个个内存“请求”，如何更合理的使用有限的内存空间的一种内存分配解决方案，它以能够依据用户的请求依次进行内存空间的分配和回收，能够尽可能少的使用有限的空闲内存空间，最大限度的保证后续“请求”的可满足性为最终目的。
二、关于动态分配方案的分析：通常我们将已分配给用户是用的一段连续的内存空间称为“占用块”，将未分配给任何用户的一段连续的内存空间称为“可利用空间块”或者“空闲块”，我们在这里的描述将使用“占用块”和“空闲块”这两个概念。
整个内存区在没有任何用户进入和运行的情况下只有一个空闲块，即整个可供用户“请求”使用的用户内存区域。
随着不断的有用户请求进入系统，并依次获得系统为其分配的内存，使得整个内存区域逐渐被分割成两大部分：低地址区域包含若干占用块；高低址区域是空闲内存区域。
经过一段时间后，有的用户运行结束，它们所占用的内存区释放后转变为一个个空闲块，这就使整个内存区域呈现出占用块和空闲块交错相隔的状态。
而此时，如果再有新的用户“请求”到达，那么，系统如何为这个“请求”进行内存分配呢？在肯定动态存储管理的前提下，我们可以采取两种方案解决这个问题，一种解决方案是系统继续把高地址的空闲块分配给用户，而不理会低地址区域是否有结束执行的用户释放的内存块，直到剩余的高地址区域的空闲块不能满足新的用户“请求”，分配操作无法再进行下去时，才去回收结束执行的用户释放的内存块，并重新组织内存，进而完成内存分配。
操作系统内存练习题及答案
题4、静态链接是在（ ）进行的；而动态链接是在（ ）或（ ）进行的，其中在（ ）进行链接，可使得内存利用率最高。
Ⅰ．编译某段程序时；Ⅱ．装入某段程序时；Ⅲ．调用某段程序时；Ⅳ．紧凑时（即内存紧缩）；Ⅴ．装入程序之前。
A）Ⅰ；Ⅱ；Ⅲ；ⅢB）Ⅲ；Ⅳ；Ⅴ；ⅣC）Ⅴ；Ⅱ；Ⅲ；ⅢD）Ⅰ；Ⅴ；Ⅲ；Ⅴ5、由连续分配方式发展为分页存储管理方式；再由分页系统发展为分段系统，进而又发展为段页式系统的主要动力是（ ）。
Ⅰ．提高内存利用率；Ⅱ．提高系统吞吐量；Ⅲ．满足编程需要；Ⅳ．既满足编程要求，又提高内存利用率。
A）ⅠB）ⅡC）ⅢD）Ⅳ6、在动态分区式内存管理中，倾向于优先使用低址部分空闲区的算法是（ ）；能使内存空间中空闲区分布得较均匀的算法是（ ）；每次分配时，把既能满足要求，又是最小的空闲区分配给进程的算法是（ ）。
Ⅰ．最佳适应算法；Ⅱ．最坏适应算法；Ⅲ．首次适应算法；Ⅳ．循环首次适应算法（即Next fit）。
A）Ⅲ；Ⅳ；ⅠB）Ⅳ；Ⅰ；ⅡC）Ⅲ；Ⅰ；ⅣD）Ⅳ；Ⅰ；Ⅱ7、在首次适应算法中，要求空闲分区按（ ）的顺序形成空闲分区链；在最佳适应算法中是按（ ）的顺序形成空闲分区链；最坏适应算法是按（ ）的顺序形成空闲链。
Ⅰ．空闲区起始地址递增；Ⅱ．空闲区起始地址递减；Ⅲ．空闲区大小递增；Ⅳ．空闲区大小递减。
A）Ⅰ；Ⅲ；Ⅱ B）Ⅰ；Ⅲ；ⅣC）Ⅲ；Ⅳ；ⅡD）Ⅲ；Ⅰ；Ⅱ8、对外存对换区的管理应以（ ）为主要目标，对外存文件区的管理应以（ ）为主要目标。
Ⅰ．提高系统吞吐量；Ⅱ．提高存储空间的利用率；Ⅲ．降低存储费用；Ⅳ．提高换入换出速度。
A）Ⅰ；ⅡB）Ⅲ；ⅣC）Ⅳ；ⅡD）Ⅰ；Ⅲ9、在页式存储管理中，其虚拟地址空间是（ ）的：在段式存储管理中，其虚拟地址空间是（ ）的；在段页式存储管理中，其虚拟地址空间是（ ）的。
Ⅰ．一维；Ⅱ．二维；Ⅲ．三维；Ⅳ．层次。
A）Ⅰ；Ⅱ；ⅡB）Ⅱ；Ⅲ；ⅣC）Ⅲ；Ⅳ；ⅠD）Ⅳ；Ⅰ；Ⅱ第 2 页共 8 页题18、在请求分页系统的页表增加了若干项，其中状态位供（）参考。
存储管理首次、最佳、最坏适应算法
最佳适应算法最佳适应算法是从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区的一种计算方法，这种方法能使碎片尽量小。
找到：满足要求的自由分区分配排序：从小到大含义最佳适应算法（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)最坏适应分配算法要扫描整个空闲分区或链表，总是挑选一个最大的空闲分区分割给作业使用。
该算法要求将所有的空闲分区按其容量从大到小的顺序形成一空闲分区链，查找时只要看第一个分区能否满足作业要求。
优点:可使剩下的空闲分区不至于太小，产生碎片的几率最小，对中、小作业有利，同时该算法查找效率很高。
缺点:会使存储器中缺乏大的空闲分区。
首次适应算法首次适应算法从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法目的在于减少查找时间。
为适应这种算法，空闲分区表(空闲区链)中的空闲分区要按地址由低到高进行排序。
c模拟内存分配算法（首次适应算法，最佳适应算法，最坏适应算法）
c模拟内存分配算法（⾸次适应算法，最佳适应算法，最坏适应算法）#include<bits/stdc++.h>using namespace std;/*定义内存的⼤⼩为100*/#define MEMSIZE 100/*如果⼩于此值，将不再分割内存*/#define MINSIZE 2/*内存分区空间表结构*/typedef struct _MemoryInfomation{/*起始地址*/int start;/*⼤⼩*/int Size;/*状态 F:空闲(Free) U:占⽤(Used) E 结束(End)*/char status;} MEMINFO;/*内存空间信息表*/MEMINFO MemList[MEMSIZE];/*显⽰内存状态*/void Display(){int i,used=0;//记录可以使⽤的总空间量printf("\n---------------------------------------------------\n");printf("%5s%15s%15s%15s","Number","start","size","status");printf("\n---------------------------------------------------\n");for(i=0; i<MEMSIZE&&MemList[i].status!='e'; i++){if(MemList[i].status=='u'){used+=MemList[i].Size;}printf("%5d%15d%15d%15s\n",i,MemList[i].start,MemList[i].Size,MemList[i].status=='u'?"USED":"FREE");}printf("\n----------------------------------------------\n");printf("Totalsize:%-10d Used:%-10d Free:%-10d\n",MEMSIZE,used,MEMSIZE-used);}/*初始化所有变量*/void InitMemList(){int i;MEMINFO temp= {0,0,'e'};//初始化空间信息表for(i=0; i<MEMSIZE; i++){MemList[i]=temp;}//起始地址为0MemList[0].start=0;//空间初始为最⼤MemList[0].Size=MEMSIZE;//状态为空闲MemList[0].status='f';}/*最先适应算法*//*算法原理分析：将空闲的内存区按其在储存空间中的起始地址递增的顺序排列，为作业分配储存空间时，从空闲区链的始端开始查找，选择第⼀个满⾜要求的空闲区，⽽不管它究竟有多⼤优点:1.在释放内存分区的时候，如果有相邻的空⽩区就进⾏合并，使其成为⼀个较⼤的空⽩区2.此算法的实质是尽可能的利⽤储存器的低地址部分，在⾼地址部分则保留多的或较⼤的空⽩区，以后如果需要较⼤的空⽩区，就容易满⾜缺点：1.在低地址部分很快集中了许多⾮常⼩的空⽩区，因⽽在空⽩区分配时，搜索次数增加，影响⼯作效率。
首次适应算法代码
首次适应算法代码首次适应算法是一种基于最少访问原则的页面置换算法，其核心思想是将最近最少使用（Least Recently Used，简称LRU）的页面替换出主存。
该算法在操作系统中广泛应用于虚拟内存的页面置换过程中，可以有效地提高系统的响应速度和效率。
```python# 首次适应算法def first_fit(processes, size):# 初始化分区列表partition = [0] * len(processes)# 查找首次适应的空闲分区for j in range(len(partition)):if partition[j] == 0:# 判断分区大小是否足够容纳该进程if processes[i] <= size[j]:partition[j] = processes[i]break# 如果没有空闲分区，返回Falseelse:return False# 如果所有进程都成功分配到分区，返回Truereturn True```在上述代码中，我们首先定义了一个名为 `first_fit` 的函数，该函数接受两个参数：进程列表 `processes` 和分区大小列表 `size`。
进程列表 `processes` 就是指所有要进行分配的进程，而分区大小列表 `size` 则是指主存中所有可用的分区大小。
接下来，我们使用一个长度为 `len(processes)` 的列表 `partition` 来记录每个进程最终分配到的分区。
列表中的每个元素都代表一个分区，如果该分区的值为0，说明该分区是空闲的。
然后，我们使用两个嵌套的 `for` 循环遍历进程列表和分区列表。
在内部 `for` 循环中，我们查找首次适应的空闲分区，并判断该分区是否足够容纳该进程。
如果找到了合适的分区，我们就将该进程分配到该分区，并跳出循环。
如果所有分区都被占用，我们就返回 `False` 表示分配失败。
在主体部分的外部，我们返回 `True` 表示所有进程都成功分配到分区。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
首次适应算法,最佳适应算法,最坏适应算法源代码[宝典] 首次适应算法,最佳适应算法,最坏适应算法源代码#include<iostream.h> #include<stdlib.h>#define Free 0 //空闲状态 #define Busy 1 //已用状态 #define OK 1 //完成#define ERROR 0 //出错#define MAX_length 640 //最大内存空间为640KBtypedef 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 First_fit(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<<"请输入需要分配的主存大小(单位:KB):"; cin>>request;if(request<0 ||request==0){cout<<"分配大小不合适，请重试～"<<endl;return ERROR;}if(ch==2) //选择最佳适应算法{if(Best_fit(request)==OK) cout<<"分配成功～"<<endl; else cout<<"内存不足，分配失败～"<<endl;return OK;}if(ch==3) //选择最差适应算法{if(Worst_fit(request)==OK) cout<<"分配成功～"<<endl; else cout<<"内存不足，分配失败～"<<endl;return OK;}else //默认首次适应算法{if(First_fit(request)==OK) cout<<"分配成功～"<<endl; else cout<<"内存不足，分配失败～"<<endl;return OK;}}//首次适应算法Status First_fit(int request){//为申请作业开辟新空间且初始化DuLinkList temp=(DuLinkList)malloc(sizeof(DuLNode)); temp->data.size=request;temp->data.state=Busy;DuLNode *p=block_first->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->prior;temp->next=p;temp->data.address=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(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;LNode *p=block_first->next; DuDuLNode *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<<"KB\t\t";if(p->data.state==Free) cout<<"空闲\n\n";else cout<<"已分配\n\n";p=p->next;}cout<<"++++++++++++++++++++++++++++++++++++++++++++++\n\n"; }//主函数void main(){int ch;//算法选择标记cout<<"请输入所使用的内存分配算法:\n";cout<<"(1)首次适应算法\n(2)最佳适应算法\n(3)最差适应算法\n"; cin>>ch;while(ch<1||ch>3){cout<<"输入错误，请重新输入所使用的内存分配算法:\n";cin>>ch;}Initblock(); //开创空间表int choice; //操作选择标记while(1){show();cout<<"请输入您的操作:";cout<<"\n1: 分配内存\n2: 回收内存\n0: 退出\n";cin>>choice;if(choice==1) alloc(ch); // 分配内存else if(choice==2) // 内存回收{int flag;cout<<"请输入您要释放的分区号:"; cin>>flag;free(flag);}else if(choice==0) break; //退出else //输入操作有误{cout<<"输入有误，请重试～"<<endl; continue;}}}。