东北大学秦计算机操作系统实验报告

计算机操作系统

实验报告

学号：

姓名：

提交日期：

2015-12-20

成绩：

东北大学秦皇岛分校

计算机与通信工程学院

操作系统实验报告

东北大学秦皇岛分校计算机与通信工程学院第

PAGE

42

页

实验1使用动态优先权的进程调度算法的模拟

1实验目的

通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。

2实验内容

（1）实现对N个进程采用动态优先权优先算法的进程调度。

（2）每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：

进程标识数ID。

进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。

进程已占用的CPU时间CPUTIME。

进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。

进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，将进入阻塞状态。

进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。

进程状态STATE。

队列指针NEXT，用来将PCB排成队列。

（3）优先数改变的原则：

进程在就绪队列中停留一个时间片，优先数加1。

进程每运行一个时间片，优先数减3。

（4）假设在调度前，系统中有5个进程，它们的初始状态如下：

ID01234

PRIORITY93830290

CPUTIME00000

ALLTIME33634

STARTBLOCK2-1-1-1-1

BLOCKTIME30000

STATEreadyreadyreadyreadyready

（5）为了清楚的观察各进程的调度过程，程序应将每个时间片内的情况显示出来，参照的具体格式如下：

RUNNINGPROG：i

READY-QUEUE：->id1->id2

BLOCK-QUEUE：->id3->id4

=======================================

ID01234

PRIORITYP0P1P2P3 P4

CUPTIMEC0C1C2C3C4

ALLTIMEA0A1A2A3A4

STARTBLOCKT0T1T2T3T4

BLOCKTIMEB0B1B2B3B4

STATES0S1S2S3S4

3实验结果（给出编写的程序源代码和运行结果的截图）

#include<iostream>

#include<string.h>

usingnamespacestd;

ints;//优先权数

intm;//被调用的进程号

intjiuxun[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};

intjiuxunnum=0;

intzhuse[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};

intzhusenum=0;

intover[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};

intovernum=0;

//memset(jiuxun,-1,10);

intqueueOutput();

structpcb{

intid;

intpriority;

intcputime;

intalltime;

intstarb;

intbtime;

stringstate;//0：就绪1：完成-1:阻塞

};

structpcbproject[5]={

{0,9,0,3,2,3,"READY"},

{1,38,0,3,-1,0,"READY"},

{2,30,0,6,-1,0,"READY"},

{3,29,0,3,-1,0,"READY"},

{4,0,0,4,-1,0,"READY"}

};

intmaxpriority(){//寻找最大优先权进程

//s=project[0].priority;

m=0;

for(intk=0;k<=zhusenum;k++){

if(m==zhuse[k])

m++;

}

intmaxp=project[m].priority;

intminalltime=project[m].alltime;

for(inti=0;i<5;i++){

/*if(project[i].starb<=0){

jiuxun[jiuxunnum]=i;

jiuxunnum++;

}*/

if(project[i].priority>maxp&&project[i].starb!=0){

maxp=project[i].priority;

m=project[i].id;

}elseif(project[i].priority==maxp){

if(project[i].alltime<minalltime&&project[i].starb!=0){

minalltime=project[i].alltime;

m=project[i].id;

}

}

}

returnm;

}

intrunning(){//执行进程并进行属性值变换

intnow=maxpriority();

project[now].priority-=3;

for(inti=0;i<5;i++){

if(i!=now&&project[i].state!="FINISH")

project[i].priority++;

if(project[i].starb==0&&project[i].btime>0){

project[i].btime--;

if(project[i].btime==0){

project[i].state="READY";

jiuxun[jiuxunnum]=i;

jiuxunnum++;

for(intk=0;k<=zhusenum;k++){

if(zhuse[k]==i){

zhuse[k]=-1;

}

}

}

}

}

project[now].cputime++;

project[now].alltime--;

if(project[now].starb>0){

project[now].starb--;

if(project[now].starb==0){

zhuse[zhusenum]=now;

zhusenum++;

project[now].state="BLOCK";

for(intj=0;j<jiuxunnum;j++){

if(jiuxun[j]==now)

jiuxun[j]=-1;

}

}

}

if(project[now].alltime==0){

project[now].state="FINISH";

project[now].priority=0;

over[overnum]=now;

overnum++;

for(intk=0;k<jiuxunnum;k++){

if(jiuxun[k]==now)

jiuxun[k]=-1;

}

}

}

intoutput(){

running();

cout<<"now"<<"process"<<m<<"isrunning...\n"<<endl;

queueOutput();

/*cout<<"READY-QUEUE:";

for(inti=0;i<=jiuxunnum;i++){

if(jiuxun[i]!=-1)

cout<<"->"<<jiuxun[i];

}

cout<<"\t";

cout<<"BLOCK-QUEUE:";

for(intj=0;j<=zhusenum ;j++){

if(zhuse[j]!=-1)

cout<<"->"<<zhuse[j];

}

cout<<endl<<endl;*/

cout<<"ID\t\t"<<"0\t"<<"1\t"<<"2\t"<<"3\t"<<"4\t"<<endl;

cout<<"PRIORITY\t"<<project[0].priority<<"\t"<<project[1].priority<<"\t"<<project[2].priority<<"\t"<<project[3].priority<<"\t"<<project[4].priority<<"\t"<<endl;

cout<<"CPUTIME\t\t"<<project[0].cputime<<"\t"<<project[1].cputime<<"\t"<<project[2].cputime<<"\t"<<project[3].cputime<<"\t"<<project[4].cputime<<"\t"<<endl;

cout<<"ALLTIME\t\t"<<project[0].alltime<<"\t"<<project[1].alltime<<"\t"<<project[2].alltime<<"\t"<<project[3].alltime<<"\t"<<project[4].alltime<<"\t"<<endl;

cout<<"STARTBLOCK\t"<<project[0].starb<<"\t"<<project[1].starb<<"\t"<<project[2].starb<<"\t"<<project[3].starb<<"\t"<<project[4].starb<<"\t"<<endl;

cout<<"BLOCKTIME\t"<<project[0].btime<<"\t"<<project[1].btime<<"\t"<<project[2].btime<<"\t"<<project[3].btime<<"\t"<<project[4].btime<<"\t"<<endl;

cout<<"STATE\t\t"<<project[0].state<<"\t"<<project[1].state<<"\t"<<project[2].state<<"\t"<<project[3].state<<"\t"<<project[4].state<<"\t"<<endl;

cout<<endl;

}

intqueueOutput(){

cout<<"READY-QUEUE:";

for(inti=0;i<=jiuxunnum;i++){

if(jiuxun[i]!=-1)

cout<<"->PC"<<jiuxun[i];

}

cout<<"\n";

cout<<"BLOCK-QUEUE:";

for(intj=0;j<=zhusenum ;j++){

if(zhuse[j]!=-1)

cout<<"->PC"<<zhuse[j];

}

cout<<endl;

cout<<"****************************************************";

cout<<endl;

}

intmain(){

cout<<"**************2133625储蓉蓉**************"<<endl;

cout<<"初始化进程:\n";

cout<<"ID\t\t"<<"0\t"<<"1\t"<<"2\t"<<"3\t"<<"4\t"<<endl;

cout<<"PRIORITY\t"<<project[0].priority<<"\t"<<project[1].priority<<"\t"<<project[2].priority<<"\t"<<project[3].priority<<"\t"<<project[4].priority<<"\t"<<endl;

cout<<"CPUTIME\t\t"<<project[0].cputime<<"\t"<<project[1].cputime<<"\t"<<project[2].cputime<<"\t"<<project[3].cputime<<"\t"<<project[4].cputime<<"\t"<<endl;

cout<<"ALLTIME\t\t"<<project[0].alltime<<"\t"<<project[1].alltime<<"\t"<<project[2].alltime<<"\t"<<project[3].alltime<<"\t"<<project[4].alltime<<"\t"<<endl;

cout<<"STARTBLOCK\t"<<project[0].starb<<"\t"<<project[1].starb<<"\t"<<project[2].starb<<"\t"<<project[3].starb<<"\t"<<project[4].starb<<"\t"<<endl;

cout<<"BLOCKTIME\t"<<project[0].btime<<"\t"<<project[1].btime<<"\t"<<project[2].btime<<"\t"<<project[3].btime<<"\t"<<project[4].btime<<"\t"<<endl;

cout<<"STATE\t\t"<<project[0].state<<"\t"<<project[1].state<<"\t"<<project[2].state<<"\t"<<project[3].state<<"\t"<<project[4].state<<"\t"<<endl;

cout<<endl;

for(inti=0;i<5;i++){

if(project[i].state=="READY"){

jiuxun[jiuxunnum]=i;

jiuxunnum++;

}

}

intj=5,count=0;

queueOutput();

getchar();

while(j!=count){

output();

for(inti=0;i<j;i++){

if(project[i].state=="FINISH"){

count++;

}else{

count=0;

}

}

getchar();

}

}

实验心得体会：由于网上给出了动态优先权优先算法，所以参考网上给出的算法，加上自己对于本次实验的理解和题目中的要求，来对其进行实现，实验难点在于对算法原理的理解和对程序的实现，查阅了资料理解了算法，但是由于基础知识的不扎实，自己对于程序的整体写的思路还是没有，最后还是在同学的帮助下完成。

实验2使用动态分区分配方式的模拟

1实验目的

（1）了解动态分区分配方式中使用的数据结构和分配算法

（2）加深对动态分区存储管理方式及其实现过程的理解。

2实验内容

（1）分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。其中，空闲分区通过空闲分区链来管理：在进行内存分配时，系统优先使用空闲区低端的空间。

（2）假设初始状态下，可用的内存空间为640KB，并有下列的请求序列：

•作业1申请130KB。

•作业2申请60KB。

•作业3申请100KB。

•作业2释放60KB。

•作业4申请200KB。

•作业3释放100KB。

•作业1释放130KB。

•作业5申请140KB。

•作业6申请60KB。

•作业7申请50KB。

•作业6释放60KB。

分别采用首次适应算法和最佳适应算法，对内存块进行分配和回收，要求每次分配和回收后显示出空闲分区链的情况。

3实验结果（给出编写的程序源代码和运行结果的截图）

#include<iostream>

usingnamespacestd;

/*

*定义空闲分区链结构

*/

structSubareaNode

{

//分区起始地址

intaddress;

//分区大小

intsize;

//分区状态(0,1)

intstate;

//作业号

inttaskNo;

//分区前向指针

SubareaNode*prior;

//分区后向指针

SubareaNode*next;

};

/*

*定义动态分区分配类

*/

classDynamicSubareaAlloction

{

private:

//内存分区链指针

SubareaNode*head;

//内存空间大小

intMEMORYSPACE;

public:

/*

*在构造函数中初始化内存大小

*/

DynamicSubareaAlloction()

{

cout<<"请输入内存可用空间大小(大小范围0k至640k)："<<endl;

do

{

cin>>MEMORYSPACE;

if((MEMORYSPACE<0)||(MEMORYSPACE>640))

{

cout<<"不符合内存可用空间大小范围！"<<endl;

}

}while((MEMORYSPACE<0)||(MEMORYSPACE>640));

cout<<"内存空间可用为"<<MEMORYSPACE<<"k"<<endl;

}

/*

*对内存进行分区分配

*int:内存分配算法选项

*/

voidexecAlloction(intoption)

{

//初始内存分区链

head=newSubareaNode;

head->size=MEMORYSPACE;

head->address=0;

head->state=0;

head->taskNo=0;

head->prior=NULL;

head->next=NULL;

//定义作业号范围变量

inttask[7]={0,0,0,0,0,0,0};

//操作选项变量

intselectItem=0;

//作业号变量

intno;

//内存大小变量

intspace;

//是否显示内存情况

boolisShow;

if(1==option)

{

cout<<"你选择了首次适应算法!"<<endl;

}

elseif(2==option)

{

cout<<"你选择了最佳适应算法!"<<endl;

}

//选择申请或释放内存操作

while(1)

{

cout<<"=========================="<<endl;

cout<<"/n请选择一项操作:"<<endl;

cout<<"/n1--申请内存"<<endl;

cout<<"/n2--释放内存"<<endl;

cout<<"/n0--终止操作"<<endl;

cout<<"=========================="<<endl;

do

{

cin>>selectItem;

if(1!=selectItem&&2!=selectItem&&0!=selectItem)

{

cout<<"输入选项错误，请重新输入!"<<endl;

}

}while(1!=selectItem&&2!=selectItem&&0!=selectItem);

//退出程序

if(0==selectItem)

{

//释放内存分区链

deletehead;

head=NULL;

break;

}

//检查作业号是否有效

while(1)

{

cout<<"请输入作业号：(作业号范围1～7),输入'0'终止操作!"<<endl;

cin>>no;

//终止操作

if(0==no)break;

if(no<1||no>7)

{

cout<<"超出作业号范围!"<<endl;

}

elseif(1<=no<=7)

{

if(1==task[no-1]&&1==selectItem)

{

cout<<"此作业号已申请内存,重新输入!"<<endl;

}

elseif(0==task[no-1]&&2==selectItem)

{

cout<<"此作业号已释放内存,重新输入!"<<endl;

}

else

{

break;

}

}

}

//终止操作

if(0==no)break;

isShow=true;

//申请内存操作

if(1==selectItem)

{

//检查申请内存大小是否有效

cout<<"请输入申请内存大小：(单位:k)"<<endl;

cin>>space;

while(space>MEMORYSPACE)

{

cout<<"申请内存大小超过总共内存空间("<<MEMORYSPACE<<"k),重新输入!"<<endl;

cin>>space;

}

if(1==option)

{

//首次适应算法内存分配

//如果申请失败,不显示内存情况

if(!firstFit_alloc(head,&space,&no,task))isShow=false;

}

else

{

//最佳适应算法内存分配

//如果申请失败,不显示内存情况

if(!bestFit_alloc(head,&space,&no,task))isShow=false;

}

}

//释放内存操作

if(2==selectItem)

{

if(1==option)

{

//首次适应算法内存释放

firstFit_free(head,&no,task);

}

else

{

//最佳适应算法内存释放

bestFit_free(head,&no,task);

}

}

//输出当前内存使用情况

if(isShow)disply(head);

}

}

/*

*通用算法分配内存

*return:int

*SubareaNode:分区链指针

*int:分区大小指针

*int:作业号指针

*int[]:作业号范围指针

*/

intFit_alloc(SubareaNode*pSeek,int*spaceSize,

int*workNo,intwork[])

{

//定义分区链指针变量

SubareaNode*pTemp=NULL;

//定义是否找到合适的空闲分区标志

intret=0;

//对符合条件的空闲分区划分内存空间

while(pSeek)

{

//空闲分区状态为未分配

if(0==pSeek->state)

{

//核心算法:1

if((*spaceSize)==pSeek->size)

{

//申请内存空间大小与当前分区空间大小一致

pSeek->state=1;

pSeek->taskNo=*workNo;

ret=1;

break;

}

if((*spaceSize)<pSeek->size)

{

//新增加分区作为当前分区划分空间后余下的空闲分区

pTemp=newSubareaNode;

pTemp->address=(*spaceSize)+pSeek->address;

pTemp->next=pSeek->next;

pTemp->prior=pSeek;

pTemp->size=pSeek->size-(*spaceSize);

pTemp->state=0;

pTemp->taskNo=0;

//原分区属性调整

pSeek->next=pTemp;

pSeek->size=*spaceSize;

pSeek->state=1;

pSeek->taskNo=*workNo;

//新增分区的下一分区属性调整

if(pTemp->next)

{

pTemp->next->prior=pTemp;

}

ret=2;

break;

}

//算法结束

}

pSeek=pSeek->next;

}

if(ret>0)

{

//记录输入的作业号

work[(*workNo)-1]=1;

}

else

{

cout<<"没有找到大小合适的空闲分区,申请失败!"<<endl;

}

returnret;

}

/*

*首次适应算法分配内存

*return:bool

*SubareaNode:分区链指针

*int:分区大小指针

*int:作业号指针

*int[]:作业号范围指针

*/

boolfirstFit_alloc(SubareaNode*pSeek,int*spaceSize,

int*workNo,intwork[])

{

boolflag=false;

intval=0;

//对符合条件的空闲分区划分内存空间

val=Fit_alloc(pSeek,spaceSize,workNo,work);

if(val>0)flag=true;

returnflag;

}

/*

*最佳适应算法分配内存

*return:bool

*SubareaNode:分区链指针

*int:分区大小指针

*int:作业号指针

*int[]:作业号范围指针

*/

boolbestFit_alloc(SubareaNode*pbestSeek,int*bestSize,

int*bestNo,intbestwork[])

{

boolflag=false;

intval=0;

//对符合条件的空闲分区划分内存空间

val=Fit_alloc(pbestSeek,bestSize,bestNo,bestwork);

//划分完内存空间后需重新按空间大小排序

if(val==2)sortNode();

if(val>0)flag=true;

returnflag;

}

/*

*首次适应算法回收内存

*SubareaNode:分区链指针

*int:作业号指针

*int[]:作业号范围指针

*/

voidfirstFit_free(SubareaNode*pfirstFree,int*FirstNo,intFirstwork[])

{

//定义分区链指针变量

SubareaNode*pCurrently=NULL;

SubareaNode*pNext=NULL;

//定义前一个分区空闲标志

boolprevious=false;

//定义后一个分区空闲标志

boolnext=false;

while(pfirstFree)

{

//核心算法:2

//寻找作业号所在内存分区

if((*FirstNo)==pfirstFree->taskNo)

{

//释放分区前一个分区是否空闲

if(pfirstFree->prior)

{

if(0==pfirstFree->prior->state)

{

previous=true;

}

}

//释放分区后一个分区是否空闲

if(pfirstFree->next)

{

if(0==pfirstFree->next->state)

{

next=true;

}

}

//与前后分区合并

if(previous&&next)

{

cout<<"已释放内存，并与前后空闲分区合并."<<endl;

pCurrently=pfirstFree;

pNext=pfirstFree->next;

pfirstFree->prior->size=pCurrently->size+pfirstFree->prior->size+pNext->size;

pfirstFree->prior->next=pNext->next;

pfirstFree->prior->state=0;

pfirstFree->prior->taskNo=0;

//调整前分区新的下一分区前驱指针

if(pNext->next)pNext->next->prior=pfirstFree->prior;

//释放变量指针

deletepCurrently;

deletepNext;

pCurrently=NULL;

pNext=NULL;

}

//与前分区合并

if(previous&&!next)

{

cout<<"已释放内存，并与前一个空闲分区合并."<<endl;

pCurrently=pfirstFree;

pfirstFree->prior->size=pCurrently->size+pfirstFree->prior->size;

pfirstFree->prior->next=pCurrently->next;

pfirstFree->prior->state=0;

pfirstFree->prior->taskNo=0;

//调整前分区新的下一分区前驱指针

if(pCurrently->next)pCurrently->next->prior=pfirstFree->prior;

//释放变量指针

deletepCurrently;

pCurrently=NULL;

}

//与后分区合并

if(!previous&&next)

{

cout<<"已释放内存，并与后一个空闲分区合并."<<endl;

pNext=pfirstFree->next;

//调整当前分区属性

pfirstFree->size=pfirstFree->size+pNext->size;

pfirstFree->next=pNext->next;

pfirstFree->state=0;

pfirstFree->taskNo=0;

//调整当前分区新的下一分区前驱指针

if(pfirstFree->next)pfirstFree->next->prior=pfirstFree;

//释放变量指针

deletepNext;

pNext=NULL;

}

//调整当前分区状态

if(!previous&&!next)

{

cout<<"释放当前分区."<<endl;

pfirstFree->state=0;

pfirstFree->taskNo=0;

}

//调整作业号状态

Firstwork[(*FirstNo)-1]=0;

break;

}

pfirstFree=pfirstFree->next;

//算法结束

}

}

/*

*最佳适应算法回收内存

*SubareaNode:分区链指针

*int:作业号指针

*int[]:作业号范围指针

*/

voidbestFit_free(SubareaNode*pbestFree,int*jobNo,intjob[])

{

//定义分区链指针变量

SubareaNode*pPrevious=NULL;

SubareaNode*pNext=NULL;

SubareaNode*pfree=pbestFree;

//定义前一个分区空闲标志

boolprevious=false;

//定义后一个分区空闲标志

boolnext=false;

while(pbestFree)

{

//核心算法:4

//寻找作业号所在内存分区

if((*jobNo)==pbestFree->taskNo)

{

while(pfree)

{

if(0==pfree->state)

{

//释放分区前一个分区是否空闲

if(pbestFree->address==(pfree->address+pfree->size))

{

previous=true;

pPrevious=pfree;

}

//释放分区后一个分区是否空闲

if(pfree->address==(pbestFree->address+pbestFree->size))

{

next=true;

pNext=pfree;

}

}

pfree=pfree->next;

}

//与前后分区合并

if(previous&&next)

{

cout<<"已释放内存，并与前后空闲分区合并."<<endl;

pbestFree->size=pPrevious->size+pbestFree->size+pNext->size;

pbestFree->state=0;

pbestFree->taskNo=0;

pbestFree->address=pPrevious->address;

//删除前分区

deleteNode(pPrevious);

deleteNode(pNext);

sortNode();

}

//与前分区或者后分区合并

if((previous&&!next)||(!previous&&next))

{

if(previous)

{

cout<<"已释放内存，并与前一个空闲分区合并."<<endl;

pNext=pPrevious;

pbestFree->address=pNext->address;

}

if(next)

{

cout<<"已释放内存，并与后一个空闲分区合并."<<endl;

}

//调整当前分区属性

pbestFree->size=pbestFree->size+pNext->size;

pbestFree->state=0;

pbestFree->taskNo=0;

//删除分区

deleteNode(pNext);

sortNode();

}

//调整当前分区状态

if(!previous&&!next)

{

cout<<"释放当前分区."<<endl;

pbestFree->state=0;

pbestFree->taskNo=0;

}

//调整作业号状态

job[(*jobNo)-1]=0;

break;

}

pbestFree=pbestFree->next;

//算法结束

}

}

/*

*删除分区节点

*SubareaNode:分区链指针

*/

voiddeleteNode(SubareaNode*pDel)

{

//删除分区

//如果删除分区是第一节点

if(NULL==pDel->prior)

{

head=pDel->next;

}

else

{

pDel->prior->next=pDel->next;

}

//如果删除分区是最后一节点

if(NULL==pDel->next)

{

pDel->prior->next=NULL;

}

else

{

pDel->next->prior=pDel->prior;

}

//释放变量指针

deletepDel;

pDel=NULL;

}

/*

*对空闲分区链表重新按空间大小排序

*/

voidsortNode()

{

//定义指针数组保存空闲分区链表指针

SubareaNode*parr[20];

//定义数组保存空闲分区的空间大小值

intarr[20];

intlen=0;

SubareaNode*pt=NULL;

pt=head;

//核心算法3

//采用快速排序算法进行重新排序

while(pt)

{

parr[len]=pt;

arr[len]=pt->size;

len++;

pt=pt->next;

}

improved_qsort(parr,arr,0,len-1);

//根据数组指针对空闲分区排序

for(inti=0;i<len;i++)

{

//只有一个节点不执行排序

if(1==len)break;

//第一个节点

if(0==i)

{

head=parr[i];

parr[i]->prior=NULL;

parr[i]->next=parr[i+1];

}

//最后一个节点

elseif(i==len-1)

{

parr[i]->prior=parr[i-1];

parr[i]->next=NULL;

}

else

{

parr[i]->prior=parr[i-1];

parr[i]->next=parr[i+1];

}

}

//算法结束

}

/*

*快速排序算法

*SubareaNode[]:空闲分区链表指针数组

*int[]:整形数组

*int:最低数组下标

*int:最高数组下标

*/

voidimproved_qsort(SubareaNode*parr[],intarr[],intlow,inthigh)

{

if(low>=high)return;

inti=low;

intj=high+1;

intpivot=arr[i];

inttemp;

SubareaNode*ptemp=NULL;

while(i<j)

{

for(i=i+1;i<high;i++)

{

if(arr[i]>=pivot)break;

}

for(j=j-1;j>low;j--)

{

if(arr[j]<=pivot)break;

}

if(i<j)

{

//交换数组中空间大小值

temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

//交换数组指针中的指针

ptemp=parr[i];

parr[i]=parr[j];

parr[j]=ptemp;

}

}

temp=arr[j];

arr[j]=arr[low];

arr[low]=temp;

ptemp=parr[j];

parr[j]=parr[low];

parr[low]=ptemp;

improved_qsort(parr,arr,low,j-1);

improved_qsort(parr,arr,i,high);

}

/*

*输出内存分区情况

*SubareaNode:分区链指针

*/

voiddisply(SubareaNode*point)

{

cout<<"++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;

cout<<"+当前内存分配情况如下：+"<<endl;

cout<<"++"<<endl;

cout<<"+起始地址|空间大小|状态|作业号+"<<endl;

while(point)

{

cout<<"/n++"<<endl;

//输出起始地址

cout<<"/n+"<<int2str(point->address)<<"k|";

//输出空间大小

cout<<""<<int2str(point->size)<<"k|";

//输出内存空间使用状态

if(0==point->state)

{