操作系统实验四动态分区分配算法源代码最新最全Word文档格式.docx

操作系统实验四动态分区分配算法源代码最新最全Word文档格式.docx

《操作系统实验四动态分区分配算法源代码最新最全Word文档格式.docx》由会员分享，可在线阅读，更多相关《操作系统实验四动态分区分配算法源代码最新最全Word文档格式.docx（13页珍藏版）》请在冰豆网上搜索。

intFreePartition[MaxNumber];

//空闲分区大小

intFirstPartition[MaxNumber];

//1-首次适应算法

intCycleFirstPartition[MaxNumber];

//2-循环首次适应算法

intBestPartition[MaxNumber];

//3-最佳适应算法

intWorstPartition[MaxNumber];

//4-最坏适应算法

intProcessNeed[MaxNumber];

//进程需要的分区大小

intPartitionNum,ProcessNum;

charProcessName[MaxNumber];

//进程名

charProcessPartition[MaxNumber];

//进程分配的序列

intPartition[MaxNumber];

charstr[MaxNumber][MaxNumber];

voidFirstFit（intn,intm）;

voidNextFit（intn,intm）;

voidBestFit（intn,intm）;

voidWorstFit（intn,intm）;

voidPrint（intn,intm）;

voidPrint2（intn,intm）;

//========================================================

voidFirstFit（intn,intm）

{

cout<

<

"

选择了首次适应算法!

endl;

inti,j,k=0;

for（i=0;

i<

n;

i++）

{

FirstPartition[i]=FreePartition[i];

}

for（j=0;

j<

m;

j++）

for（i=0;

{

if（ProcessNeed[j]<

=FirstPartition[i]）

{

ProcessPartition[j]=i;

//str[i][k]=ProcessName[j];

FirstPartition[i]=FirstPartition[i]-ProcessNeed[j];

break;

}

}

Print（n,m）;

空间序号:

"

;

cout<

|"

setw（m-1）<

空间"

（i+1）;

分区大小:

setw（m）<

setiosflags（ios:

:

left）<

FreePartition[i];

剩余分区大小:

FirstPartition[i];

Print2（n,m）;

}

voidNextFit（intn,intm）

选择了循环首次适应算法!

inti,j,flag=0;

CycleFirstPartition[i]=FreePartition[i];

for（i=flag;

=CycleFirstPartition[i]）

CycleFirstPartition[i]=CycleFirstPartition[i]-ProcessNeed[j];

flag=i+1;

if（i==n-1）

{

flag=0;

}

CycleFirstPartition[i];

voidBestFit（intn,intm）

选择了最佳适应算法!

inti,j,flag=0,temp,id=0,flag1=0;

BestPartition[i]=FreePartition[i];

while（flag1<

m）

flag=0;

Partition[i]=0;

if（ProcessNeed[flag1]<

=BestPartition[i]）

Partition[flag]=i;

flag+=1;

temp=BestPartition[Partition[0]];

id=Partition[0];

for（i=1;

flag;

if（temp>

BestPartition[Partition[i]]）

temp=BestPartition[Partition[i]];

id=Partition[i];

BestPartition[id]=BestPartition[id]-ProcessNeed[flag1];

ProcessPartition[flag1]=id;

flag1+=1;

BestPartition[i];

voidWorstFit（intn,intm）

选择了最坏适应算法!

WorstPartition[i]=FreePartition[i];

=WorstPartition[i]）

temp=WorstPartition[Partition[0]];

if（WorstPartition[Partition[i]]>

temp）

temp=WorstPartition[Partition[i]];

WorstPartition[id]=WorstPartition[id]-ProcessNeed[flag1];

WorstPartition[i];

}

voidchoice（intn,intm）

intintput;

\n请选择：

1.首次适应算法2.循环首次适应算法3.最佳适应算法4.最坏适应算法:

cin>

>

intput;

switch（intput）

case1:

FirstFit（n,m）;

choice（n,m）;

break;

case2:

NextFit（n,m）;

case3:

BestFit（n,m）;

case4:

WorstFit（n,m）;

voidPrint（intn,intm）

intj;

进程名:

j++）

ProcessName[j];

进程分区大小:

ProcessNeed[j];

分配结果:

voidPrint2（intn,intm）

inti,j;

for（j=0;

str[i][j]=0;

进程分配分区:

intk=0;

if（ProcessPartition[j]==i）

str[i][k]=ProcessName[j];

k+=1;

cout<

setw

（1）<

str[i][j];

//===============================================================

voidmain（）

ifstreamin（"

yin.txt"

）;

intn,m;

in>

in>

choice（n,m）;

运行结果：