㈠ 2.采用首次适应算法和最佳适应算法模拟实现可变分区管理。
#define MAX 100
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int b;//存放进程本次结束时的时间
void main()
{
int i,N,t,k;
int a[MAX];//存放进程的剩余时间
int cnt[MAX];//存放进程调度次数
printf("请输入进程数N:");
scanf("%d",&N);
printf("\n请输入时间片t大小:");
scanf("%d",&t);
printf("\n请依次输入各个进程的服务时间");
for(i=0;i<N;i++)
{
scanf("%d",&a[i]);
cnt[i]=0;
}
printf("被调度进程\t进程调度次数 \t本次运行时间结果\t剩余时间\n");
k=1;
while(k)
{
for(i=0;i<N;i++)
{
if(a[i]!=0)
if(a[i]>=t)
{
a[i]-=t;
b+=t;
cnt[i]=cnt[i]+1;
printf("\n\t%d\t\t%d\t\t%d\t\t%d",i+1,cnt[i],b,a[i]);
}
else
{
b=b+a[i];
cnt[i]=cnt[i]+1;
a[i]=0;
printf("\n\t%d\t\t%d\t\t%d\t\t%d",i+1,cnt[i],b,a[i]);
}
else continue;
}
for(i=0;i<N;i++)
if(a[i]!=0)
{ k=1;break;}
else continue;
if(i>=N)
k=0;
}
printf("\n");
printf("进程全部运行完成!");
printf("\n");
}
㈡ 【高分悬赏】用C/C++语言设计一个适应算法（最先、最佳或最坏适应算法）
考的是内存的动态划分区域内容，很好写啊
1.可以用数字来模拟内存区域划分情况，比如建一个100大小的数组（结构为struc （区号，值），值为0表示空闲，值为1表示占用，初始化几个已确定占有的分区，分区一，1-5 占有，6-12 空闲，。。。。。。。，并建立空闲区域表，很简单，从头到尾对数组扫描下就知道了
2.最先适应：从内存开始地址找到第一个大于请求大小的连续空闲区域，如请求5个空间，那就在刚开始6-12空闲处建立分区二 ，6-11 ，占用
3.最佳适应：指所有空闲块最适应请求大小的那块，min（空闲块大小-请求大小）
4.最坏：指适应请求大小，且最大的那块空闲区域
㈢ 设计一个实现适应算法的程序
#include <IOSTREAM.H>
#include <STDLIB.H>
typedef struct LNode
{ int size; //内存大小
int state; //0表示空闲，1表示已经装入作业
char task_name; //装入的作业名称
struct LNode *next;
}LNode,*memoryspace;
void Init(memoryspace &L,int size); //初始化空间段
void choice(memoryspace &L); //选择操作类型
void Add(memoryspace &L); //添加作业
void Display(const memoryspace L); //显示作业
void deltask(const memoryspace L); //删除作业
void setfree(memoryspace &L); //回收空闲空间
void main()
{
memoryspace L=new LNode; //memoryspace
int N;
cout<<"初始多大空间,请输入一个整数:"<<ENDL; cin>>N;
Init(L,N); //初始化大小为1000的内存空间
choice(L); //进入操作
}
void Init(memoryspace &L,int size) //初始化空间段
{
memoryspace p = new LNode;
p->size = size;
p->state = 0;
p->task_name = 'n';
p->next = NULL;
L->next = p;
}
void setfree(memoryspace &L) //找出连续的空闲资源,回收空闲空间
{
memoryspace p=L->next,q=p->next;
while(p && q)
{
if(p->state == 0 && q->state == 0) //如果空间连续,则回收
{
p->size +=q->size;
p->next = p->next->next;
delete q;
q=p->next;
}
else
{
p = q;
q = q->next;
}
}
cout<<"回收成功"<<ENDL; cin cout<<?请输入需要回收的作业名称:?; Display(L); flag="0;" int task_name; char { 删除作业 L) memoryspace deltask(const void }>>task_name;
memoryspace p=L,q=L->next;
while(q)
{
if(q->task_name == task_name)
{
q->state=0;
q->task_name='?';
flag=1;
break;
}
else
{
p = q;
q = q->next; //找到要删除作业的下一个结点
}
}
if(flag == 0)
cout<<"删除作业不成功"<<ENDL; int { L) memoryspace void } p="L-" count="1;" 显示作业 Display(const cout<<?删除作业成功?<<endl; else>next;
cout<<"结点号 作业 状态 大小"<<ENDL; { ?<<p- cout<<?结点?<<count<<? while(p)>>new_name;
cout<<"请输入新任务的大小:";
cin>>new_size;
while(p) //查找空闲资源进行分配
{
if (new_size<=0)
{
cout<<ENDL<<"申请的空间不能小于1"<<ENDL; } if(p- break;>state==0 && p->size >= new_size)
{
//
memoryspace q = new LNode;
q->size = p->size - new_size;
q->state = 0;
q->task_name='?';
q->next=NULL;
//
p->size = new_size;
p->state = 1;
p->task_name=new_name;
q->next = p->next;
p->next = q;
break; //分配完成便退出
}
else
{
p = p->next; //移动到足够分配的空结点
}
if(!p)
{
cout<<"作业"<<NEW_NAME<<"内存分配不成功"<<ENDL; } p="L-" break;>next;
while(p) //删除大小为0的结点,当分配空间完时会出现0结点
{
if(p->size == 0)
{
q->next = q->next->next;
delete p;
p = q->next;
}
else
{
q = p;
p = p->next;
}
}
}
void choice(memoryspace &L) //选择操作类型
{
int choice;
do
{
cout<<"0.退出本程序"<<ENDL; cin cout<<endl<<?输入你的选择:?; cout<<?4.回收空闲空间?<<endl; cout<<?3.删除一条作业?<<endl; cout<<?2.显示当前作业?<<endl; cout<<?1.添加新的作业?<<endl;>>choice;
switch(choice)
{
case 0:
exit(1);break;
case 1:
Add(L); break;
case 2:
Display(L); break;
case 3:
deltask(L); break;
case 4:
setfree(L); break;
default:
cout<<"请输入正确的选择!"<<ENDL; } break; pre < choice!="3" || !="2" choice ||choice!="1" }while(choice!="0" cout<<endl;>
<SCRIPT src="/inc/gg_read2.js"></SCRIPT>CRIPT>
//从空闲区分配空间
if(itfreetmp->partionlen==joblen)
{
freetable.erase(itfreetmp);
}
else
{
itfreetmp->baseaddr=itfreetmp->baseaddr+joblen;
itfreetmp->partionlen=itfreetmp->partionlen-joblen;
}
cout<<"为作业"<<jobname<<"分配内存成功！"<<endl;
return;
}
else
{
cout<<"内存不足，为作业分配内存失败！"<<endl;
return;
}
}
void ReclaimMem(string jobname)//回收作业jobname所占的内存
{
list<usedpartion>::iterator itused=usedtable.begin();
list<freepartion>::iterator itfree=freetable.begin();
freepartion free;
while(itused!=usedtable.end())
{
if(itused->jobname==jobname)//找到要回收的作业
{
free.baseaddr=itused->baseaddr;
free.partionlen=itused->partionlen;
usedtable.erase(itused);
if(itfree!=freetable.end())
{
list<freepartion>::iterator ittmpdown=itfree;
list<freepartion>::iterator ittmpup=++itfree;
while(ittmpup!=freetable.end())
{
if(free.baseaddr==(ittmpdown->baseaddr+ittmpdown->partionlen))//下邻空闲区
{
if(free.baseaddr+free.partionlen==ittmpup->baseaddr)//下邻空闲区,上邻空闲区
{
ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen+ittmpup->partionlen;
freetable.erase(ittmpup);//删除上邻空闲区
cout<<"回收作业所占的内存成功！"<<endl;
return;
}
else//下邻空闲区,但不上邻空闲区
{
ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen;
cout<<"回收作业所占的内存成功！"<<endl;
return;
}
}
else if(free.baseaddr+free.partionlen==ittmpup->baseaddr)//上邻空闲区,但不下邻空闲区
{
ittmpup->baseaddr=free.baseaddr;
ittmpup->partionlen=free.partionlen+ittmpup->partionlen;
cout<<"回收作业所占的内存成功！"<<endl;
return;
}
else//既不下邻空闲区又不上邻空闲区
{
if((free.baseaddr<ittmpup->baseaddr)&&(free.baseaddr>ittmpdown->baseaddr)) {
freetable.insert(ittmpup,free);
cout<<"回收作业所占的内存成功！"<<endl;
return;
}
else
{
if(free.baseaddr<ittmpdown->baseaddr)//小于空闲区下限
{
freetable.insert(ittmpdown,free);
cout<<"回收作业所占的内存成功！"<<endl;
return;
}
else//大于空闲区上限
{
ittmpdown=ittmpup;
itfree++;
ittmpup=itfree;
continue;
}
}//
}//else既不下邻空闲区又不上邻空闲区
}//while
if(ittmpup==freetable.end())
{
if(ittmpdown->baseaddr>free.baseaddr)
{
if(free.baseaddr+free.partionlen==ittmpdown->baseaddr)//上邻空闲区
{
ittmpdown->baseaddr=free.baseaddr;
ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen;
cout<<"回收作业所占的内存成功！"<<endl;
return;
}
else//不上邻空闲区
{
freetable.insert(ittmpdown,free);
cout<<"回收作业所占的内存成功！"<<endl;
return;
}
}
else
{
if(ittmpdown->baseaddr+ittmpdown->partionlen==free.baseaddr)//下邻空闲区
{
ittmpdown->partionlen=ittmpdown->partionlen+free.partionlen;
cout<<"回收作业所占的内存成功！"<<endl;
return;
}
else
{
freetable.push_back(free);
cout<<"回收作业所占的内存成功！"<<endl;
return;
}
}
}//if(ittmpup==freetable.end())
/*else//没有遍历到空闲区表的末尾就已更新表
{
cout<<"回收作业所占的内存成功！"<<endl;
return;
}*/
}//if(itfree!=NULL)
else//空闲分区表为空
{
freetable.push_back(free);
cout<<"回收作业所占的内存成功！"<<endl;
return;
}
}//if(itused...)
else //未找到要回收的作业
{
itused++;
}
}//while
if( itused==usedtable.end())
{
cout<<"未找到要回收的作业,请确定所输入的作业名是否正确！"<<endl;
}
}
㈣ 求首次适应算法的c语言程序！（计算机操作系统的）
最佳适应算法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";
}
未完。请自己从参考资料上复制。
㈤ C语言，“最优数字分配策略” 谁能给个思路
最佳适应算法是从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区的一种计算方法，这种方法能使碎片尽量小。
最佳适应算法（Best Fit）：
它从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区，这种方法能使碎片尽量小。为适应此算法，空闲分区表（空闲区链）中的空闲分区要按从小到大进行排序，自表头开始查找到第一个满足要求的自由分区分配。该算法保留大的空闲区，但造成许多小的空闲区。
Best fit算法等价于装箱问题，举例如下：
装箱问题：有体积为V的箱子N个，体积为Vi的物品M个，求使得物品全部能够装入箱子，箱子数量的最小值。
假设 V=6 N=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的最小值。
㈥ 求用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 <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
struct memory
{
struct memory *former;
int address;//地址
int num;//作业号
int size;//分配内存大小
int state;//状态0表示空闲1表示已分配
struct memory *next;
};
typedef struct memory MEMORY;
MEMORY *mem;
const int size_min=10;//内存允许的最小空闲块的大小
bool is_optimist=false;//判断是否是最佳适应算法
void init();
void FF();
void alloc(MEMORY *,MEMORY *);//首次适应算法分配内存
void free(MEMORY *);//首次适应算法回收内存
void sort(MEMORY *);//对内存链进行排序
void insert(MEMORY *,MEMORY *);
void free_optimist(MEMORY *);
void print(MEMORY *);//打印内存链
void main()
{
int i=0;
while(1)
{
cout<<("\nPlease select a number(1,2,0)");
cout<<("\n 1--首次适应算法");
cout<<"\n 2--最佳适应算法"<<endl;
cout<<" 0--中止程序"<<endl;
cin>>i;
if(i==1)
{
cout<<("\nThis is an example for FF:\n");
is_optimist=false;
init();
FF();
}
else if(i==2)
{
cout<<"\nThis is an example for optimist method;\n";
is_optimist=true;
init();
FF();
}
else if(i==0)
{
exit(1);
}
}
}
void init()
{
mem=new MEMORY;
mem->size=640;
//mem->state=0;
mem->former=0;
mem->next=0;
}
void FF()//首次适应算法
{
int i;
int work[]={130,60,100,200,140,60,50};//作业序列
//int assignment;
MEMORY *running;
for(i=0;i<sizeof(work)/sizeof(int);i++)
{
running=(MEMORY *)malloc(sizeof(MEMORY));//初始化作业
if(running!=NULL)
{
running->former=NULL;
running->address=0;
running->num=i+1;
running->size=work[i];
running->state=0;
running->next=NULL;
//cout<<"作业初始化成功"<<running->num<<endl;
if(is_optimist==true)//最佳适应算法
{
//cout<<""<<endl;
alloc(mem,running);
}
else//首次适应算法
{
alloc(mem,running);
}
print(mem);
cout<<endl;
}
else
cout<<"没有足够的内存空间"<<endl;
if(rand()%3==1)
{
if(is_optimist==false)//首次适应算法
{
free(mem);
}
else//最佳适应算法
{
::free_optimist(mem);
}
}
}
}
void free(MEMORY *ptr)//作业处理完后释放内存空间
{
MEMORY *previous,*current;
previous=ptr;
current=previous->next;
while(current!=NULL)
{
if(current->state==1&&rand()%3==1)
{
break;
}
previous=current;
current=current->next;
}
if(current==NULL)
{
//cout<<"内存中没有任何作业！！！"<<endl;
return;
}
else if(current->next==NULL)
{
if(previous->state==0)
{
MEMORY *temp;
temp=current;
previous->size=previous->size+current->size;
previous->next=NULL;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp;
print(mem);
}
else
{
current->state=0;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
print(mem);
}
}
else if((current->next)->next==NULL)
{
if(previous->state==0&&(current->next)->state==0)
{
MEMORY *temp1,*temp2;
temp1=current;
temp2=current->next;
previous->size=previous->size+current->size+(current->next)->size;
previous->next=NULL;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp1;
delete temp2;
print(mem);
}
else if(previous->state==0)//释放的地址空间前面有空闲块则把它和前面的合并
{
MEMORY *temp;
temp=current;
previous->size=previous->size+current->size;
(current->next)->former=previous;
previous->next=current->next;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp;
print(mem);
}
else if((current->next)->state==0)//释放的地址空间后面有空闲块则把它和后面的空闲块合并
{
MEMORY *temp;
temp=current->next;
current->size=current->size+(current->next)->size;
current->state=0;
current->next=NULL;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp;
print(mem);
}
else//处理完的作业前后都没有空闲块时直接把它的状态改为没分配
{
current->state=0;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
print(mem);
}
}
else
{
if(previous->state==0&&(current->next)->state==0)
{
MEMORY *temp1,*temp2;
temp1=current;
temp2=current->next;
previous->size=previous->size+current->size+(current->next)->size;
((current->next)->next)->former=previous;
previous->next=(current->next)->next;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp1;
delete temp2;
print(mem);
}
else if(previous->state==0)//释放的地址空间前面有空闲块则把它和前面的合并
{
MEMORY *temp;
temp=current;
previous->size=previous->size+current->size;
(current->next)->former=previous;
previous->next=current->next;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp;
print(mem);
}
else if((current->next)->state==0)//释放的地址空间后面有空闲块则把它和后面的空闲块合并
{
MEMORY *temp;
temp=current->next;
current->size=current->size+(current->next)->size;
current->state=0;
((current->next)->next)->former=current;
current->next=(current->next)->next;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp;
print(mem);
}
else//处理完的作业前后都没有空闲块时直接把它的状态改为没分配
{
current->state=0;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
print(mem);
}
}
}
void alloc(MEMORY *ptr,MEMORY *assign)//内存分配
{
if(ptr->next==NULL)//内存没有作业运行
{
if(ptr->size>=assign->size)//内存空间大于作业所需空间
{
ptr->size=ptr->size-assign->size;//为内存分配空间
assign->state=1;
ptr->next=assign;
assign->former=ptr;
cout<<"作业 "<<(assign->num)<<"申请"<<(assign->size)<<" "<<"k的内存空间"<<endl;
}
else
{
cout<<"没有足够的内存空间为作业"<<(assign->num)<<"分配"<<endl;
delete assign;
}
}
else//内存中如果已经分配了空间
{
MEMORY *previous,*current;
previous=ptr;
current=previous->next;
while(current!=NULL)
{
if(current->size>assign->size&¤t->state==0)//如果当前内存空间大于作业所需空间并且内存没有被分配
{
break;
}
previous=current;
current=current->next;
}
if(current==NULL)//空闲链中没有为作业分配所需的空间
{
if(ptr->size>=assign->size)//内存中还有足够没分配的空间为此作业分配
{
assign->address =640-(ptr->size);//max+size_offset;//作业在内存中的首地址
ptr->size=ptr->size-assign->size;
assign->state=1;
assign->former=previous;
previous->next=assign;
cout<<"作业 "<<(assign->num)<<"申请"<<(assign->size)<<" "<<"k的内存空间"<<endl;
}
else
{
cout<<"没有足够的内存空间为作业"<<(assign->num)<<"分配"<<endl;
}
}
else//空闲链中有可为此作业分配的空间
{
if((current->size-assign->size)<=size_min)//空闲链所具备的空间与作业所需空间大小差不多时
{ //直接把整个空闲块的空间分配给作业否则从空闲块中
current->num=assign->num; //划出与作业等同的空间
current->state=1;
delete assign;//free(assign);
cout<<"作业 "<<(current->num)<<"申请"<<(current->size)<<" "<<"k的内存间"<<endl;
}
else//从空闲块中划分一块与作业大小等同的空间
{
current->size=current->size-assign->size;
assign->state=1;
assign->address=current->address+current->size;
if(current->next==NULL)//此要分配的空间是空闲链的最后一个元素
{
assign->former=current;
current->next=assign;
}
else
{
assign->next=current->next;
(current->next)->former=assign;
assign->former=current;
current->next=assign;
}
cout<<"作业 "<<(assign->num)<<"申请"<<(assign->size)<<" "<<"k的内存空间"<<endl;
}
}
}
if((ptr->next)->next!=NULL&&is_optimist==true)
sort(ptr);//排序由空闲块从小到大
//print(ptr);
}
void sort(MEMORY *ptr)
{
MEMORY *temp=new MEMORY;
temp->next=0;
temp->former=0;
while(ptr->next)
{
if((ptr->next)->next==NULL)//内存链中只有两个元素
{
MEMORY *p;
p=ptr->next;
ptr->next=NULL;
insert(temp,p);
}
else//内存链中有多个元素
{
MEMORY *p;
p=ptr->next;
p->former=ptr;
ptr->next=p->next;
(p->next)->former=ptr;
insert(temp,p);
}
}
ptr->next=temp->next;
(temp->next)->former=ptr;
delete temp;
}
void insert(MEMORY *queue,MEMORY *item)
{
MEMORY *previous,*current;
previous=queue;
current=previous->next;
while(current!=NULL && item->size>=current->size)
{
previous=current;
current=current->next;
}
if(previous==queue)//所要插入的元素最小
{
if(queue->next==NULL)//内存链中只有一个元素
{
item->next=0;
queue->next=item;
item->former=queue;
}
else//内存链中有多个元素
{
item->next=queue->next;
(queue->next)->former=item;
item->former=queue;
queue->next=item;
}
}
else//定位到要插入的元素
{
item->next=current;
item->former=previous;
if(current==NULL)
{
previous->next=item;
}
else
{
current->former=item;
previous->next=item;
}
}
}
void free_optimist(MEMORY *ptr)
{
MEMORY *previous,*current;
previous=ptr;
current=previous->next;
while(current!=NULL)
{
if(current->state==1&&rand()%3==1)
{
break;
}
previous=current;
current=current->next;
}
if(current==NULL)
{
//cout<<"内存中没有任何作业！！！"<<endl;
return;
}
else if(current->next==NULL)
{
if(previous->state==0&&((previous->address+previous->size)==current->address))
{
MEMORY *temp;
temp=current;
previous->size=previous->size+current->size;
previous->next=NULL;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp;
print(mem);
}
else
{
current->state=0;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
print(mem);
}
}
else if((current->next)->next==NULL)
{
if(previous->state==0&&(current->next)->state==0&&((previous->address+previous->size)==current->address)&&((current->size+current->address)==(current->next)->address))
{
MEMORY *temp1,*temp2;
temp1=current;
temp2=current->next;
previous->size=previous->size+current->size+(current->next)->size;
previous->next=NULL;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp1;
delete temp2;
print(mem);
}
else if(previous->state==0&&((previous->address+previous->size)==current->address))//释放的地址空间前面有空闲块则把它和前面的合并
{
MEMORY *temp;
temp=current;
previous->size=previous->size+current->size;
(current->next)->former=previous;
previous->next=current->next;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp;
print(mem);
}
else if((current->next)->state==0&&((current->size+current->address)==(current->next)->address))//释放的地址空间后面有空闲块则把它和后面的空闲块合并
{
MEMORY *temp;
temp=current->next;
current->size=current->size+(current->next)->size;
current->state=0;
current->next=NULL;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp;
print(mem);
}
}
else
{
if(previous->state==0&&(current->next)->state==0&&((previous->address+previous->size)==current->address)&&((current->size+current->address)==(current->next)->address))
{
MEMORY *temp1,*temp2;
temp1=current;
temp2=current->next;
previous->size=previous->size+current->size+(current->next)->size;
((current->next)->next)->former=previous;
previous->next=(current->next)->next;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp1;
delete temp2;
print(mem);
}
else if(previous->state==0&&(previous->address+previous->size)==current->address)//释放的地址空间前面有空闲块则把它和前面的合并
{
MEMORY *temp;
temp=current;
previous->size=previous->size+current->size;
previous->state=0;
(current->next)->former=previous;
previous->next=current->next;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp;
print(mem);
}
else if((current->next)->state==0&&((current->size+current->address)==(current->next)->address))//释放的地址空间后面有空闲块则把它和后面的空闲块合并
{
MEMORY *temp;
temp=current->next;
current->size=current->size+(current->next)->size;
current->state=0;
((current->next)->next)->former=current;
current->next=(current->next)->next;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
delete temp;
print(mem);
}
else//处理完的作业前后都没有空闲块时直接把它的状态改为没分配
{
current->state=0;
cout<<"作业 "<<(current->num)<<"释放 "<<(current->size)<<"k 的空间"<<endl;
print(mem);
}
}
if((ptr->next)->next!=NULL)
sort(ptr);//排序由空闲块从小到大
}
void print(MEMORY *ptr)
{
MEMORY *temp;
temp=ptr->next;
cout<<"\n内存链的状态为："<<endl;
while(temp!=NULL)
{
cout<<"分配的地址为："<<temp->address<<" 分配的空间："<<temp->size<<"k"
<<" 运行的作业号:"<<temp->num;
if(temp->state==0)
{
cout<<" 内存空闲";
}
else
{
cout<<" 内存已分配";
}
cout<<endl;
temp=temp->next;
}
}