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

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

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

iostream>

fstream>

iomanip>

usingnamespacestd;

constintMaxNumber=100;

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];

se