首次适应算法最佳适应算法最坏适应算法源代码宝典.docx

首次适应算法最佳适应算法最坏适应算法源代码宝典.docx

《首次适应算法最佳适应算法最坏适应算法源代码宝典.docx》由会员分享，可在线阅读，更多相关《首次适应算法最佳适应算法最坏适应算法源代码宝典.docx（9页珍藏版）》请在冰豆网上搜索。

首次适应算法最佳适应算法最坏适应算法源代码宝典

首次适应算法，最佳适应算法,最坏适应算法源代码［宝典］

首次适应算法，最佳适应算法,最坏适应算法源代码iiinclude#include

#defineFree0//空闲状态#defineBusy1//已用状态tidefineOK1//完成

^defineERROR0//出错

#defineMAX_length640//最大内存空间为640KBtypedefintStatus;

intflag;

typedefstructfreearea//定义一个空闲区说明表结构

{

longsize;〃分区大小

longaddress;//分区地址

intstate;//状态}ElemType;

//线性表的双向链表存储结构typedefstructDuLNode{

ElemTypedata;

structDuLNode*prior;//前趋指针

structDuLNode*next;//后继指针}

DuLNode,*DuLinkList;

DuLinkListblock_first;//头结点DuLinkListblock_last;//尾结点

Statusalloc（int）;//内存分配Statusfree（int）;//内存回收

StatusFirst_fit（int）;//首次适应算法

StatusBest_fit（int）;//最佳适应算法StatusWorst_fit（int）;//最差适应算法

voidshow（）;//查看分配

StatusInitblockO;//开创空间表

StatusInitblock（）//开创带头结点的内存空间链表

{

block_first=（DuLinkList）malloc（sizeof（DuLNode））;block_last=（DuLinkList）malloc（sizeof（DuLNode））;block_first~>prior=NULL;

blockfirst-〉next二blocklast;

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;

returnOK;

}

〃分配主存

Statusalloc（intch）

{

intrequest=0;

cout«，z请输入需要分配的主存大小（单位:

KB）:

〃；cin»request;

if（request<0request==0）

cout«z，分配大小不合适，请重试〜，z«endl;

returnERROR;

}

if（ch-2）〃选择最佳适应算法

{

if（Best_fit（request）~0K）cout«，/分配成功〜，z«endl;

elsecout«，?

内存不足，分配失败〜"«endl;

returnOK;

}

if（ch-3）//选择最差适应算法

{

if（Worst_fit（request）~0K）cout«z，分配成功〜，，«endl;elsecout«，/内存不足，分配失败〜，，«endl;

returnOK;

}

else〃默认首次适应算法

{

if（First_fit（request）—OK）cout«，z分配成功〜，，«endl;

elsecout«，?

内存不足，分配失败〜"«endl;

returnOK;

}

}

//首次适应算法

StatusFirst_fit（intrequest）

〃为申请作业开辟新空间且初始化

DuLinkListtemp=（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;

returnOK;

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;

returnOK;

break;

}

p=p->next;

}

returnERROR:

}

//最佳适应算法

StatusBest_fit（intrequest）

{

intch;〃记录最小剩余空间

DuLinkListtemp=（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））

{

辻（q二二NULL）

q二P；

ch=p->data・size-request;

}

elseif（q->data.size>p->data.size）

returnOK;

}

//最差适应算法

StatusWorst_fit（intrequest）

{

intch;//记录最大剩余空间

DuLinkListtemp=（DuLinkList）malloc（sizeof（DuLNode））;

temp->data・size二request;

temp-〉data・state=Busy;

LNode*p=block_first->next;Du

DuLNode*q=NULL;//记录最佳插入位置

while（p）//初始化最大空间和最佳位置

{

if（p->data・state二二Free&&（p->data・size〉二request））

{

辻（q二二NULL）

q二P；

ch=p->data・size-request;

}

elseif（q->data.sizedata.size）

q二P；

ch=p->data・size-request;

}

}

p=p->next;

}

辻（q二二NULL）returnERROR;//没有找到空闲块

elseif（q->data・size=request）

{

q->data・state二Busy;

returnOK;

}

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;

returnOK;

}

returnOK;

}

〃主存回收

Statusfree（intflag）

DuLNode*p=block_first;

for（inti=0;i<=flag;i++）

辻（p!

二NULL）

p=p->next;

else

returnERROR;

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;

}

辻（p->next==block_last&&p->next->data.state二二Free）//与最后的空闲块相连

{

p->data・size+=p->next~>data・size;

p->next二NULL;

}

returnOK;

}

〃显示主存分配情况

voidshow（）

{

intflag=0;

cout«，z\n主存分配情况:

\n";

cout〈〈"++++++++++++++++++++++++++++++++++++++++++++++\n\rT;

DuLNode*p=block_first->next:

cout«，z分区号\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";

elsecout«，z已分配\n\n";

p=p->next;

}

cout〈〈"++++++++++++++++++++++++++++++++++++++++++++++\n\n";

}

//主函数

voidmain（）

{

intch;//算法选择标记

cout«〃请输入所使用的内存分配算法:

\rT;

cout

（2）最佳适应算法\n（3）最差适应算法\n〃;

cin»ch;

while（ch3）

{

cout«，z输入错误，请重新输入所使用的内存分配算法:

\n〃；

cin»ch;

}

InitblockO:

//开创空间表

intchoice;//操作选择标记

while

（1）

{

show（）;

cout«〃请输入您的操作：

〃；

cout«，，\nl:

分配内存\n2:

回收内存\n0:

退出\n";

cin»choice;

if（choice=l）alloc（ch）;//分配内存

elseif（choice=2）//内存回收

intflag;

cout«zz请输入您