采用首次适应算法例题

⑴ 采用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");
}
}
}

⑵ 设计一个实现适应算法的程序

#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;
}
}

⑶ 采用首次适应算法回收内存时,可能出现哪几种情况应该怎样处理这些情况 采用首次适应算法

a. 回收区与插入点的前一个分区相邻接，此时可将回收区与插入点的前一分区合并，不再为回收分区分配新表项，而只修改前邻接分区的大小；
b. 回收分区与插入点的后一分区相邻接，此时合并两区，然后用回收区的首址作为新空闲区的首址，大小为两者之和；
c. 回收区同时与插入点的前后两个分区邻接，此时将三个分区合并，使用前邻接分区的首址，大小为三区之和，取消后邻接分区的表项；
d. 回收区没有邻接空闲分区，则应为回收区单独建立一个新表项，填写回收区的首址和大小，并根据其首址，插入到空闲链中的适当位置

⑷ 鐜版湁濡备笅浣滀笟搴忓垪:浣滀笟1瑕佹眰60kb锛屼綔涓2瑕佹眰65kb锛屼綔涓3瑕佹眰85kb銆傝嫢鐢ㄩ栨￠傚簲绠楁硶鍜屾渶浣抽傚簲绠楁硶𨱒ュ勭悊

镐诲唴瀛樻槸澶氩皯锛熸疮涓浣滀笟钖勯渶瑕佽繍琛屽氶暱镞堕棿锛

⑸ 求首次适应算法的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";
}

未完。请自己从参考资料上复制。

⑹ 首次适应算法是什么

First-fit (FF)是一种用于装箱的在线算法。

它的输入是一个不同大小的项目列表。它的输出是一个包装——将物品分成固定容量的箱子，这样每个箱子中物品的大小之和最多就是容量。理想情况下，我们希望使用尽可能少的 bin，但是最小化 bin 的数量是一个 NP-hard 问题。首次拟合算法使用以下启发式：

它保留一个打开的垃圾箱列表，最初是空的。

当一件物品到达时，它会找到该物品可以放入 的第一个箱子（如果有的话）。

如果找到这样的箱子，则将新物品放入其中。

否则，将打开一个新的箱子并将即将到来的物品放入其中。

优缺点

1、优点

处理速度快。由于处理器将最近的可用内存分区分配给作业，因此执行速度非常快。

2、缺点

浪费大量内存。处理器忽略分配给作业的分区大小与作业大小相比是否非常大。它只是分配内存。结果，浪费了大量内存，许多作业可能无法在内存中获得空间，并且必须等待另一个作业完成。