首次适应算法
最佳适应算法C++程序：
struct list // 初始化数据的结构体
{
int num;
int adr;
int end;
int size;
}s[]={{1,1000,2999,2000},{2,500,799,300},{3,3500,3699,200},{4,4000,4499,500}}; // 初始化空闲分区
/*void print(struct list *p,int n) // print函数作用输出结果
{
int flag1=1;
int flag2=1;
int i,j=0;
cout<<"-------------------------------------\n";
for(i=0;i {
if(p->size==0) // 控制不输出size=0的空闲块
{
flag2=0;
j++;
continue;
}
else
flag2=1;
if(p->size!=0&&flag2!=0)
{
flag1=0;
cout<<"序号:"<num-j/*输出的序号仍然是从1开始*//*<<" 起始位置:"<adr<<" 终止位置:"<end<<" 空闲块大小:"<size< }
}
if(flag1==1) // 当所有的空闲块正好被分配完时
cout<<"\n空闲内存已被分配完，请回收！\n";
cout<<"-------------------------------------\n";
}*/
void print(struct list a[],int n) // print函数作用输出结果
{
int i;
cout<<"-------------------------------------\n";
if(a[0].size==0)
{
for(i=0;i {
a[i].adr=a[i+1].adr;
a[i].size=a[i+1].size;
a[i].end=a[i+1].end;
}
k=k-1;
}
if(k==0)
cout<<"\n空闲块已经分配完毕,需要再分配,请回收!\n";
for(i=0;i cout<<"序号:"< cout<<"-------------------------------------\n";
}
未完。请自己从参考资料上复制。
② 首次适应算法，最佳适应算法和最坏适应算法怎么分配资源
首次适应算法要求空闲分区链以空闲分区开始地址递增的次序链接，从链首开始顺序查找，直至找到一个能满足程序大小要求的空闲分区为止
最佳适应算法技能满足要求，又是最小的空闲分区
最差适应算法总是找到一个满足程序长度要求的最大空闲分区
③ 采用首次适应算法和最优置换算法,对内存的分配和回收速度会造成什么不同的影响
首次适应分配算法(FF):
对空闲分区表记录的要求是按地址递增的顺序排列的，每次分配时，总是从第1条记录开始顺序查找空闲分区表，找到第一个能满足作业长度要求的空闲区，分割这个空闲区，一部分分配给作业，另一部分仍为空闲区。
最佳置换算法（OPT):
选择以后永不使用或在最长时间内不再被访问的内存页面予以淘汰。
④ 求操作系统首次适应算法，要求内存分配大小自己定，分配后还有多大内存，总之就是建立二级菜单
问题一：⑴ 存储管理的实质是什么？(对内存的管理，主要对内存中用户区进行管理)⑵ 多道程序中，为方便用户和充分利用内存以提高内存利用率，内存管理的任务是什么？(内存空间的分配和回收、内存空间的共享、存储保护、地址映射、内存扩充)。⑶ 如何实现存储保护？ 答：在多道程序系统中，内存中既有操作系统，又有许多用户程序。为使系统正常运行，避免内存中各程序相互干扰，必须对内存中的程序和数据进行保护。1、防止地址越界对进程所产生的地址必须加以检查，发生越界时产生中断，由操作系统进行相应处理。2、防止操作越权对属于自己区域的信息，可读可写；对公共区域中允许共享的信息或获得授权可使用的信息，可读而不可修改；对未获授权使用的信息，不可读、不可写。存储保护一般以硬件保护机制为主，软件为辅，因为完全用软件实现系统开销太大，速度成倍降低。当发生越界或非法操作时，硬件产生中断，进入操作系统处理(4) 物理存储器分几类？(内存、外存、缓存)⑸ 虚存储器的含义是什么？(两层含义)答：虚存储器有两层含义，一是指用户程序的逻辑地址构成的地址空间；二是指当内存容量不满足用户要求时，采用一种将内存空间与外存空间有机地结合在一起，利用内外存自动调度的方法构成一个大的存储器，从而给用户程序提供更大的访问空间。⑹ 什么叫物理地址？什么叫逻辑地址？什么叫地址映射？地址映射分哪几类？(静态、动态)答：物理地址是内存中各存储单元的编号，即存储单元的真实地址，它是可识别、可寻址并实际存在的。用户程序经过编译或汇编形成的目标代码，通常采用相对地址形式，其首地址为零，其余指令中的地址都是相对首地址而定。这个相对地址就称为逻辑地址或虚拟地址。逻辑地址不是内存中的物理地址，不能根据逻辑地址到内存中存取信息。为了保证CPU执行程序指令时能正确访问存储单元，需要将用户程序中的逻辑地址转运行时可由机器直接寻址的物理地址，这一过程称为地址映射或地址重定位。地址映射可分为两类：1、静态地址映射2、动态地址映射问题二：⑴ 怎样对内存进行分区？(静态、动态；等长、不等长)答：对内存空间的划分是可以静态的，也可以动态的；可以是等长的，也可以不等长。静态划分是指系统运行之前就将内存空间划分成若干区域，通常，分配给进程的内存可能比进程实际所需的区域长。动态划分是在系统运行过程中才划分内存空间。这样，系统可按进程所需要的存储空间大小为其分配恰好满足要求的一个或多个区域。等长分区是将存储空间划分为若干个长度相同的区域。不等长分区则是将存储空间划分若干个长度不同的区域。⑵ 根据分区情况，从如何实现进程的内存分配？答：1、静态等长分区的分配2、动态异长分区的分配⑶ 什么叫碎片？(零散的小空闲区) 怎样解决碎片问题？(紧凑技术)答：所谓碎片是指内存中出现的一些零散的小空闲区域。解决碎片的方法是移动所有占用区域，使所有的空闲区合并成一片连续区域。这一过程称为紧凑，这一技术就是紧凑技术。。问题三：⑴ 存储管理方案有哪些？(分区管理、页式管理、段式管理、段页式管理、虚拟存储管理)⑵ 分区管理的基本思想是什么？主要缺点是什么？基本思想：将内存划分成若干连续的区域，称为分区，每个分区装入一个运行作业。主要缺点：不能充分利用内存，也不能实现对内存的扩充。⑶ 什么是固定分区？什么是可变分区？各有什么优缺点？答：固定分区：系统将内存划分为若干固定的分区，当作业申请内存时，系统为其选择一个适当的分区，并装入内存运行。由于分区大小是事先固定的，因而可容纳作业的大小受到限制，而且当用户作业的地址空间小于分区的存储空间时，浪费了一些存储空间。可变分区：是指在作业装入内存时建立分区，使分区的大小正好与作业要求的存储空间相等。引入可变分区方法，使内存分配有较大的灵活性，也提高了内存利用率。但是可变分区会引起碎片的产生。⑷ 分区管理可以采用的内存分配策略是什么？首先适应算法、最佳适应算法、最坏适应算法。⑸ 为实现地址映射和存储保护，系统为用户程序提供了哪些寄存器？基址寄存器、限长寄存器；上界寄存器、下界寄存器。问题四：⑴ 试述页式存储管理的基本原理① 内存划分。② 逻辑地址空间划分。③ 页面大小。④ 内存分配。⑵ 试述页式存储管理的实现方法①
⑤ 首次适应算法的介绍
首次适应算法从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法目的在于减少查找时间。为适应这种算法，空闲分区表(空闲区链)中的空闲分区要按地址由低到高进行排序。该算法优先使用低址部分空闲区，在低址空间造成许多小的空闲区，在高地址空间保留大的空闲区。
⑥ 在采用首次适应算法回收内存时,可能出现哪几种情况应怎么样处理这些情况
a. 回收区与插入点的前一个分区相邻接，此时可将回收区与插入点的前一分区合并，不再为回收分区分配新表项，而只修改前邻接分区的大小；
b. 回收分区与插入点的后一分区相邻接，此时合并两区，然后用回收区的首址作为新空闲区的首址，大小为两者之和；
c. 回收区同时与插入点的前后两个分区邻接，此时将三个分区合并，使用前邻接分区的首址，大小为三区之和，取消后邻接分区的表项；
d. 回收区没有邻接空闲分区，则应为回收区单独建立一个新表项，填写回收区的首址和大小，并根据其首址，插入到空闲链中的适当位置.
⑦ 求用C语言写出首次适应分配算法的分配过程~
/********************************
内存管理模拟程序
*******************************/
#include<iostream.h>
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include <time.h>
#include <windows.h>
/*定义宏*/
#define TotalMemSize 1024 /*划分的物理块的大小，地址范围0~1023*/
#define MinSize 2 /*规定的不再分割的剩余分区的大小*/
#define getpch(type) (type*)malloc(sizeof(type))
/*定义内存块*/
typedef struct memBlock
{
struct memBlock *next;/*指向下一个块*/
int stAddr; /*分区块的初始地址*/
int memSize; /*分区块的大小*/
int status; /*分区块的状态，0：空闲，1：以被分配*/
}MMB;
/*定义全局变量*/
MMB *idleHead=NULL; /*空闲分区链表的头指针*/
MMB *usedHead=NULL; /*分配分区链表的头指针*/
MMB *usedRear=NULL; /*分配分区链表的链尾指针*/
MMB *np; /*循环首次适应算法中指向即将被查询的空闲块*/
int idleNum=1;/*当前空闲分区的数目*/
int usedNum=0;/*当前已分配分区的数目*/
MMB *memIdle=NULL; /*指向将要插入分配分区链表的空闲分区*/
MMB *memUsed=NULL; /*指向将要插入空闲分区链表的已分配分区*/
int flag=1;/*标志分配是否成功，1：成功*/
/*函数声明*/
void textcolor (int color);/*输出着色*/
void InitMem();/*初始化函数*/
int GetUseSize(float miu,float sigma); /*获得请求尺寸*/
MMB *SelectUsedMem(int n);/*选择待释放的块*/
void AddToUsed();/*将申请到的空闲分区加到分配分区链表中*/
int RequestMemff(int usize); /*请求分配指定大小的内存,首次适应算法*/
int RequestMemnf(int usize); /*请求分配指定大小的内存,循环首次适应算法*/
void AddToIdle();/*将被释放的分配分区加到空闲分区链表中(按地址大小）*/
void ReleaseMem(); /*释放指定的分配内存块*/
/*主函数*/
void main()
{
int sim_step;
float miu,sigma; /*使随机生成的请求尺寸符合正态分布的参数*/
int i;
int a;
MMB *p;
/* double TotalStep=0,TotalSize=0,TotalRatio=0,TotalUSize=0,Ratio=0,n=0;
double aveStep=0,aveSize=0,aveRatio=0;
int step=0,usesize=0; */
textcolor(11);
printf("\n\t\t内存管理模拟程序\n\n");
/* InitMem();*/
while(true)
{
double TotalStep=0,TotalSize=0,TotalRatio=0,TotalUSize=0,Ratio=0,n=0;
double aveStep=0,aveSize=0,aveRatio=0;
int step=0,usesize=0;
InitMem();
textcolor(12);
printf("\n\n首次适应算法： 0");
printf("\n循环首次适应算法： 1\n");
textcolor(11);
printf("\n请选择一种算法：");
scanf("%d",&a);
textcolor(15);
printf("\n输入一定数量的步数：(sim_step)");
scanf("%d",&sim_step);
printf("\n 输入使随机生成的请求尺寸符合正态分布的参数：miu,sigma ");
scanf("%f,%f",&miu,&sigma);
for(i=1;i<=sim_step;i++)
{
textcolor(10);
printf("\n\n#[%d]\n",i);
do{
usesize=GetUseSize(miu,sigma);
while((usesize<0)||(usesize>TotalMemSize))
{
usesize=GetUseSize(miu,sigma);
}
textcolor(13);
printf("\n\n申请的内存尺寸为：%d",usesize);
printf("\n此时可用的空闲分区有 %d 块情况如下：",idleNum);
p=idleHead;
textcolor(15);
while(p!=NULL)
{
printf("\n始址:%d\t 尺寸：%d",p->stAddr,p->memSize);
p=p->next;
}
TotalSize+=usesize;
if(a==0)
step=RequestMemff(usesize);
else
step=RequestMemnf(usesize);
TotalStep+=step;
n++;
}while(flag==1);
p=usedHead;
while(p!=NULL)
{
TotalUSize+=p->memSize;
printf("\n始址:%d\t 尺寸：%d",p->stAddr,p->memSize);
p=p->next;
}
textcolor(11);
if(TotalUSize!=0)
{
Ratio=TotalUSize/TotalMemSize;
TotalUSize=0;
printf("\n内存利用率NO.%d :%f%c",i,100*Ratio,'%');
}
else
{
Ratio=0;
printf("\n内存利用率NO.%d :%c%c",i,'0','%');
}
TotalRatio+=Ratio;
ReleaseMem();
}
if(n!=0)
{
textcolor(10);
aveStep=TotalStep/n;
aveSize=TotalSize/n;
aveRatio=TotalRatio/sim_step;
printf("\n平均搜索步骤：%f",aveStep);
printf("\n平均请求尺寸：%f",aveSize);
printf("\n平均内存利用率：%f",aveRatio);
}
}
}
// 输出着色 /////////////////////////////////////////
void textcolor (int color)
{
SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color );
}
/******************************
函数名：InitMem()
用途：把内存初始化为一整块空闲块
****************************************/
void InitMem()
{
MMB *p;
p=getpch(MMB);
p->memSize=TotalMemSize;
p->stAddr=0;
p->status=0;
p->next=NULL;
idleHead=p;
np=idleHead;
usedHead=NULL;
usedRear=NULL;
idleNum=1;
usedNum=0;
flag=1;
memIdle=NULL;
memUsed=NULL;
}
/******************************
函数名：GetUseSize(float miu,float sigma)
用途：获得请求尺寸；
参数说明：float miu,float sigma ：正态分布的参数
返回值:申请尺寸的大小；
****************************************************/
int GetUseSize(float miu,float sigma)
{
float r1,r2;
float u,v,w;
float x,y;
do
{
r1=rand()/32767.0;
r2=rand()/32767.0;
u=2*r1-1;
v=2*r2-1;
w=u*u+v*v;
}while(w>1);
x=u*sqrt(((-log(w))/w));
y=v*sqrt(((-log(w))/w));
return miu+sigma*x;
}
/******************************
函数名：*SelectUsedMem(int n)
用途：选择待释放的块(0~n-1)
返回值：指向待释放的块的指针；
****************************************************/
MMB *SelectUsedMem(int n)
{
MMB *p;
int i,j;
if(n>0)
{
i = rand()%n ;
textcolor(5);
printf("\n\n当前已分配分区总数为：%d",n);
printf("\n待释放块的序号为：%d\n",i );
p=usedHead;
if(p!=NULL)
{
for(j=i;j>0;j--)
p=p->next;
return(p);
}
else
return(NULL);
}
else
{
printf("\n当前没有可释放的资源！\n");
}
}
/******************************
函数名：AddToUsed()
用途：将申请到的空闲分区加到分配分区链表中
***************************************************************/
void AddToUsed()
{
MMB *p;
memIdle->status=1;
if(usedHead==NULL)
{
usedHead=memIdle;
usedRear=usedHead;
}
else
{
usedRear->next=memIdle;
usedRear=memIdle;
}
usedNum++;
printf("\n当前分配分区共有%d块！",usedNum);
p=usedHead;
while(p!=NULL)
{
printf("\n始址:%d \t 尺寸：%d",p->stAddr,p->memSize);
p=p->next;
}
}
/******************************
函数名：RequestMemff(int usize)
参数说明：usize：请求尺寸的大小；
用途：请求分配指定大小的内存,首次适应算法
返回值：搜索步骤
***************************************************************/
int RequestMemff(int usize)
{
MMB *p1,*p2,*s;
int step;
int suc=0;
int size1,size2;
if(idleHead==NULL)
{
flag=0;
textcolor(12);
printf("\n分配失败！");
return 0;
}
else
{
if((idleHead->memSize)>usize)
{
size1=(idleHead->memSize)-usize;
if(size1<=MinSize)
{
memIdle=idleHead;
idleHead=idleHead->next;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=idleHead->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
idleHead->memSize=idleHead->memSize-usize;
idleHead->stAddr=idleHead->stAddr+usize;
}
step=1;
flag=1;
textcolor(12);
printf("\n分配成功！");
AddToUsed();
}
else
{
p1=idleHead;
step=1;
p2=p1->next;
while(p2!=NULL)
{
if((p2->memSize)>usize)
{
size2=(p2->memSize)-usize;
if(size2<=MinSize)
{
p1->next=p2->next;
memIdle=p2;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=p2->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
p2->memSize=p2->memSize-usize;
p2->stAddr=p2->stAddr+usize;
}
flag=1;
suc=1;
textcolor(12);
printf("\n分配成功！");
AddToUsed();
p2=NULL;
}
else
{
p1=p1->next;
p2=p2->next;
step++;
}
}
if(suc==0)
{
flag=0;
textcolor(12);
printf("\n分配失败！");
}
}
}
return step;
}
/******************************
函数名：AddToIdle()
用途：将被释放的分配分区加到空闲分区链表中(按地址递增顺序排列）
***************************************************************/
void AddToIdle()
{
MMB *p1,*p2;
int insert=0;
if((idleHead==NULL))
{
idleHead=memUsed;
idleNum++;
np=idleHead;
}
else
{
int Add=(memUsed->stAddr)+(memUsed->memSize);
if((memUsed->stAddr<idleHead->stAddr)&&(Add!=idleHead->stAddr))
{
memUsed->next=idleHead;
idleHead=memUsed;
idleNum++;
}
else
{
if((memUsed->stAddr<idleHead->stAddr)&&(Add==idleHead->stAddr))
{
idleHead->stAddr=memUsed->stAddr;
idleHead->memSize+=memUsed->memSize;
}
else
{
p1=idleHead;
p2=p1->next;
while(p2!=NULL)
{
if(memUsed->stAddr>p2->stAddr)
{
p1=p1->next;
p2=p2->next;
}
else
{
int Add1=p1->stAddr+p1->memSize;
int Add2=p2->stAddr-memUsed->memSize;
if((Add1==memUsed->stAddr)&&(memUsed->stAddr!=Add2))
{
p1->memSize=p1->memSize+memUsed->memSize;
}
if((Add1!=memUsed->stAddr)&&(memUsed->stAddr==Add2))
{
p2->memSize=p2->memSize+memUsed->memSize;
p2->stAddr=memUsed->stAddr;
}
if((Add1!=memUsed->stAddr)&&(memUsed->stAddr!=Add2))
{
memUsed->next=p2;
p1->next=memUsed;
if(np->stAddr==p2->stAddr)
np=p1->next;
idleNum++;
}
if((Add1==memUsed->stAddr)&&(memUsed->stAddr==Add2))
{
p1->memSize=p1->memSize+memUsed->memSize+p2->memSize;
p1->next=p2->next;
if((np->stAddr)==(p2->stAddr))
np=p1;
idleNum--;
}
p2=NULL;
insert=1;
}
}
if(insert==0)
{
p1->next=memUsed;
idleNum++;
}
}
}
}
}
/******************************
函数名：ReleaseMem()
用途：释放指定的分配内存块
***************************************************************/
void ReleaseMem()
{
MMB *q1,*q2;
MMB *s;
if(usedNum==0)
{
printf("\n当前没有分配分区!");
return;
}
else
{
s=SelectUsedMem(usedNum);
if(s!=NULL)
{
if(s->stAddr==usedHead->stAddr)
{
memUsed=usedHead;
usedHead=usedHead->next;
memUsed->next=NULL;
AddToIdle();
usedNum--;
}
else
{
q1=usedHead;
q2=q1->next;
while(q2!=NULL)
{
if(q2->stAddr!=s->stAddr)
{
q1=q1->next;
q2=q2->next;
}
else
{
q1->next=q2->next;
memUsed=q2;
memUsed->next=NULL;
if(q1->next==NULL)
usedRear=q1;
AddToIdle();
usedNum--;
q2=NULL;
}
}
}
}
}
}
/******************************
函数名：RequestMemnf(int usize)
参数说明：usize：请求尺寸的大小；
用途：请求分配指定大小的内存,循环首次适应算法
返回值：搜索步骤
***************************************************************/
int RequestMemnf(int usize)
{
MMB *p2,*p,*s;
int step;
int iNum=0;
int suc=0;
int size1,size2,size3;
if(idleHead==NULL)
{
flag=0;
printf("\n分配失败！");
return 0;
}
else
{
iNum=idleNum;
while(iNum>0)
{
iNum--;
if((np->memSize)>usize)
{
/*指针指向的空闲块满足条件,且正好为头指针*/
if(np->stAddr==idleHead->stAddr)
{
size1=(idleHead->memSize)-usize;
if(size1<=MinSize)
{
memIdle=idleHead;
idleHead=idleHead->next;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=idleHead->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
idleHead->memSize=idleHead->memSize-usize;
idleHead->stAddr=idleHead->stAddr+usize;
}
if((idleHead==NULL)||(idleHead->next==NULL))
np=idleHead;
else
np=idleHead->next;
}
else/*指针指向的空闲块满足条件,不为头指针*/
{
size2=(np->memSize)-usize;
if(size2<=MinSize) /*从空闲链表中删除*/
{
p=idleHead;
while(p->next->stAddr!=np->stAddr)
p=p->next;
p->next=np->next;
memIdle=np;
memIdle->next=NULL;
np=p;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=np->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
np->memSize=np->memSize-usize;
np->stAddr=np->stAddr+usize;
}
if(np->next==NULL)
np=idleHead;
else
np=np->next;
}
step=1;
flag=1;
suc=1;
textcolor(12);
printf("\n分配成功！");
AddToUsed();
iNum=0;
}
else /*当前指针指向的空闲区不满足条件*/
{
step=1;
p2=np->next;
if(p2==NULL)
{
np=idleHead;
iNum--;
}
else
{
if((p2->memSize)>usize)
{
size3=(p2->memSize)-usize;
if(size3<=MinSize)
{
np->next=p2->next;
memIdle=p2;
memIdle->next=NULL;
idleNum--;
}
else
{
s=getpch(MMB);
s->memSize=usize;
s->stAddr=p2->stAddr;
s->status=1;
s->next=NULL;
memIdle=s;
p2->memSize=p2->memSize-usize;
p2->stAddr=p2->stAddr+usize;
}
flag=1;
suc=1;
printf("\n分配成功！");
AddToUsed();
if(p2->next==NULL)
np=idleHead;
else
np=p2->next;
p2=NULL;
iNum=0;
}
else
{
np=np->next;
p2=p2->next;
iNum--;
step++;
}
}
}
// iNum--;
}
if(suc==0)
{
flag=0;
textcolor(12);
printf("\n分配失败！");
}
}
return step;
}
⑧ 采用c语言实现首次适应算法完成主存空间的分配和回收 急
有没有具体的要求，比方说数据结构方面，我这有一个，你可以参考参考
#include"stdio.h"
#include"stdlib.h"
#define
n
10
/*假定系统允许的最大作业为n，假定模拟实验中n值为10*/
#define
m
10
/*假定系统允许的空闲区表最大为m，假定模拟实验中m值为10*/
#define
minisize
100
struct{
float
address;
/*已分分区起始地址*/
float
length;
/*已分分区长度，单位为字节*/
int
flag;
/*已分配区表登记栏标志，用"0"表示空栏目*/
}used_table[n];
/*已分配区表*/
struct{
float
address;
/*空闲区起始地址*/
float
length;
/*空闲区长度，单位为字节*/
int
flag;
/*空闲区表登记栏标志，用"0"表示空栏目，用"1"表示未分配*/
}free_table[m];
/*空闲区表*/
void
main(
)
{
int
i,a;
void
allocate(char
str,float
leg);//分配主存空间函数
void
reclaim(char
str);//回收主存函数
float
xk;
char
J;/*空闲分区表初始化：*/
free_table[0].address=10240;
free_table[0].length=102400;
free_table[0].flag=1;
for(i=1;i<m;i++)
free_table[i].flag=0;/*已分配表初始化：*/
for(i=0;i<n;i++)
used_table[i].flag=0;
while(1)
{
printf("\n选择功能项（0-退出,1-分配主存,2-回收主存,3-显示主存）\n");
printf("选择功项(0~3)
:");
scanf("%d",&a);
switch(a)
{
case
0:
exit(0);
/*a=0程序结束*/
case
1:
/*a=1分配主存空间*/printf("输入作业名J和作业所需长度xk:
");
scanf("%*c%c%f",&J,&xk);
allocate(J,xk);/*分配主存空间*/
break;
case
2:
/*a=2回收主存空间*/printf("输入要回收分区的作业名");
scanf("%*c%c",&J);reclaim(J);/*回收主存空间*/
break;
case
3:
/*a=3显示主存情况*//*输出空闲区表和已分配表的内容*/
printf("输出空闲区表：\n起始地址
分区长度
标志\n");
for(i=0;i<m;i++)
printf("%6.0f%9.0f%6d\n",free_table[i].address,free_table[i].length,
free_table[i].flag);
printf("
按任意键,输出已分配区表\n");
getchar();
printf("
输出已分配区表：\n起始地址
分区长度
标志\n");
for(i=0;i<n;i++)
if(used_table[i].flag!=0)
printf("%6.0f%9.0f%6c\n",used_table[i].address,used_table[i].length,
used_table[i].flag);
else
printf("%6.0f%9.0f%6d\n",used_table[i].address,used_table[i].length,
used_table[i].flag);
break;
default:printf("没有该选项\n");
}/*case*/
}/*while*/
}/*主函数结束*/
int
uflag;//分配表标志
int
fflag;//空闲表标志
float
uend_address;
float
fend_address;
void
allocate(char
str,float
leg)
{
uflag=0;fflag=0;
int
k,i;float
ressize;
for(i=0;i<m;i++)
{
if(free_table[i].flag==1
&&
free_table[i].length>=leg)
{
fflag=1;break;
}
}
if(fflag==0)
printf("没有满足条件的空闲区\n");
else
{
ressize=free_table[i].length-leg;
for(k=0;k<n;k++)
{
if(used_table[k].flag==0)
{
if(ressize<minisize)//剩余块过小
{
used_table[k].length=free_table[i].length;
used_table[k].address=free_table[i].address;
used_table[k].flag=str;
free_table[i].length=0;
free_table[i].flag=0;
break;
}
else
{
used_table[k].address=free_table[i].address+ressize;
used_table[k].flag=str;
used_table[k].length=leg;
free_table[i].length=ressize;
break;
}
}
}//for结束
}
}
void
reclaim(char
str)
{
uflag=0;fflag=0;
int
k,i;
for(k=0;k<n;k++)
{
if(used_table[k].flag==str)
{
uflag=1;break;
}
}
if(uflag==0)
printf("\n找不到该作业!\n");
else
{
for(i=0;i<m;i++)
{
uend_address=used_table[k].address+used_table[k].length;
fend_address=free_table[i].address+free_table[i].length;
if(used_table[k].address==fend_address)//上邻
{
fflag=1;
free_table[i].length=free_table[i].length+used_table[k].length;
free_table[i].flag=1;
used_table[k].flag=0;
used_table[k].length=0;
used_table[k].address=0;
printf("\n已回收!\n");
break;
}
else
{
if(free_table[i].address==uend_address)//下邻
{
fflag=1;
free_table[i].address=used_table[k].address;
free_table[i].length=free_table[i].length+used_table[k].length;
free_table[i].flag=1;
used_table[k].flag=0;
used_table[k].length=0;
used_table[k].address=0;
printf("\n已回收!\n");
break;
}
}
}//for结束
if(fflag==0)
{
i=0;
for(i=0;i<m;i++)
{
if(free_table[i].flag==0)
{
free_table[i].address=used_table[k].address;
free_table[i].length=used_table[k].length;
free_table[i].flag=1;
used_table[k].length=0;
used_table[k].flag=0;
used_table[k].address=0;
break;
}
}
printf("\n已回收!\n");
}
}
}