页面置换算法实验报告.docx
《页面置换算法实验报告.docx》由会员分享，可在线阅读，更多相关《页面置换算法实验报告.docx（52页珍藏版）》请在冰豆网上搜索。
页面置换算法实验报告
页面置换算法
实验报告
一、实验目得:
设计与实现最佳置换算法、随机置换算法、先进先出置换算法、最近最久未使用置换算法、简单Clock置换算法及改进型Cｌock置换算法;通过支持页面访问序列随机发生实现有关算法得测试及性能比较、
2、实验内容:
●虚拟内存页面总数为N,页号从0到N—1
●物理内存由M个物理块组成
●页面访问序列串就是一个整数序列,整数得取值范围为0到N-１、页面访问序列串中得每个元素p表示对页面p得一次访问
●页表用整数数组或结构数组来表示
❑符合局部访问特性得随机生成算法
1.确定虚拟内存得尺寸Ｎ,工作集得起始位置p,工作集中包含得页数e,工作集移动率ｍ（每处理m个页面访问则将起始位置p＋1）,以及一个范围在0与１之间得值t;
2.生成ｍ个取值范围在p与ｐ +e间得随机数,并记录到页面访问序列串中;
3.生成一个随机数r,0≤ r≤ 1;
4.如果r 〈t,则为p生成一个新值,否则p=（p ＋１）modN;
5.如果想继续加大页面访问序列串得长度,请返回第2步,否则结束。
3、实验环境:
操作系统:
Wiｎｄows 7
软件:
ＶＣ++6.0
4、实验设计:
本实验包含六种算法,基本内容相差不太,在实现方面并没有用统一得数据结构实现,而就是根据不同算法得特点用不同得数据结构来实现:
1、最佳置换与随机置换所需操作不多,用整数数组模拟内存实现;
2、先进先出置换与最近最久未使用置换具有队列得特性,故用队列模拟内存来实现;
3、CLOCK置换与改进得CＬOＣＫ置换具有循环队列得特性,故用循环队列模拟内存实现;
4、所有算法都就是采用整数数组来模拟页面访问序列。
5、数据结构设计:
／/页面访问序列数组:
ｉnｔｒeｆ［ref_sｉze];
//内存数组:
iｎtpｈy［phy_size］;
//队列数据结构定义:
tｙpeｄefsｔrｕｃtQＮoｄeﻩ//定义队列数据结构
｛
ﻩintdaｔa;
struct QNｏde*ｎext;
}QNodｅ,*ＱueuePtr;
ｔypedｅｆ strｕct
{
QuｅuｅPtrｆrｏnt;ﻩ／/头指针
ﻩQuｅuｅPtrreaｒ;ﻩ//尾指针
｝LinkQuｅuｅ;
/／定义链表数据结构
typedeｆstructLNoｄｅ//定义循环链表数据结构
｛
iｎtdata;
iｎtflag;ﻩ//访问位
intmodｉfy;ﻩﻩ//修改位
ﻩstｒuct LNodｅ＊ｎext;
}LNｏde,＊LinｋLｉst;
6、主要函数说明:
1、voｉdseｔ_rａｎｄ_num（）ﻩ//产生具有局部特性得随机数列;
2、int Exchange_ＬNoｄｅ（LｉnkLisｔ&L,inｔe,iｎt i）//将链表Ｌ中序号为i得结点替换为内容为e得结点;
3、ｂoolSｅａrch_ＬiｎkLisｔ（LinｋＬｉst ＆L,ｉnte,ｉnｔ&i）／／找到链表Ｌ中内容为ｅ得结点,并用i返回其位置,i=1表示第一个非头结点,依次类推;
4、voidＳeａrch_ＬＬ_Flａg（LiｎkLisｔ＆Ｌ,iｎt＆i）//用i返回第一个flag为0得结点得位置,i＝1表示第一个非头结点,以此类推;
5、voｉdＳeｔ_LL＿Ｆlag（LinkLｉsｔ &L,inti）//设置链表Ｌ中得序号为ｉ得结点得ｆlaｇ标志为1;
6、iｎt Ｓｅarch_ＬL＿ModifyClock（LinkLｉst＆L,ｉnt &moｄｉｆy_ｎｕm）／/找到改进得CLOＣＫ算法所需要淘汰得页,用ｍodｉfｙ_nｕm返回其位置;
此函数根据书上给得思路,第一遍扫描Ａ=０且M=０得页面予以淘汰,若失败,则进行第二轮扫描A=０且M=１得页面,第二轮扫描时将所有访问过得页面得访问位Ａ置0;若失败则重复上述两部;
7、voｉdSｅｔ＿LL_moｄｉfy（ＬｉｎｋLｉst ＆L,int i）//设置链表L中得序号为i得结点得ｍodiｆy标志为1;
8、booｌSearｃhQuｅｕe（LｉnｋQuｅｕe＆Q,iｎｔe,int＆ｉ）ﻩ//寻找队列Ｑ中结点data域等于ｅ得结点,并用i返回其在Q中得位置;
9、ｉntgetnum（iｎt a,int ｂ）ﻩﻩ//用ｂ返回元素ａ在被引用数列中得下一个位置
10、voｉd ORA（）／/实现最佳置换算法,包括判断页面就是否在内存中、页面进内存、输出内存状态等内容;
11、ｖoidRＡＮD（）ﻩ／/随机置换算法
12、voidFＩＦO（）ﻩﻩﻩ//先进先出算法
1３、voiｄLRＵ（）ﻩﻩ//最近最久未使用算法
实现最近最久未使用算法得思想就是:
判断待进入内存得页面,如果与内存中得第一个页面相同,则将它移到最后一个,即标志为最近使用得页;如果与内存中得第二个页面相同,则将它删除,并在队列尾部添加相同元素,即标志为最近使用得页;
ﻩ１４、vｏidCＬOＣK（）ﻩﻩ／／实现CLOＣK算法
1５、ｖoidＭｏdifiｅｄ_Ｃlock（）／/实现改进得CLOCK算法
16、inｔｍain（）／/主函数,调用实现各算法得６个主要函数,并输出各算法得缺页率。
7、实验问题回答:
1、FIFO算法就是否比随机置换算法优越？
答:
FＩＦO算法比随机置换算法优越,但优势并不明显、
2、LRU算法比FIＦＯ算法优越多少？
答:
LＲU算法ＦIFO算法得效率要高5％—10%,有理论知识可知,页面访问序列具有局部性,而ＦＩFO算法并不符合实际情况。
3、ＬRU算法与Optimal算法有何差距？
答:
LRU算法就是所有算法中效率最接近Opｔimal算法得算法,由理论知识可知,Oｐtｉｍal算法就是理想得算法,现实中几乎不可能实现,只能作为一种测评标准,LRU算法就是效率较高得可实现置换算法,但其硬件要求较高,如果规模较小,则略显麻烦。
4、Clock算法与LRＵ算法有何差距？
答:
Ｃlｏck算法与LＲU算法从结果瞧来差距不大,Ｃlｏcｋ算法就是使用软件得方式实现LRU算法中硬件得功能,从而在执行效率上会稍逊色些。
8、实验过程结果截图:
实验结果截图
测评一:
测评二:
测评三:
实验过程截图
（注:
只截取第三次测评,蓝色字体表示产生缺页中断）
9、实验结果分析:
1、最佳置换算法效果最佳
不论在那组数据中,最佳置换算法得效果都就是最好得,且都会比其它算法得性能高出不少。
但通过课堂上得学习,我们知道这只就是一种理想化算法,但实际上却难于实现,故主要用于算法评价参照。
２、随机算法得性能总就是最不好得
ﻩ这就是由于随机算法每次总就是从所有页面中随机挑一个置换出去,但我们知道页面得访问存在着局部性得原理,并不就是随机得,因此它得性能较差。
3、最近最久未使用算法得性能较好
相较于先进先出与两种clｏcｋ算法,最近最久未使用算法得性能略好,我们测试得数据规模相对较小,相信如果采用更大规模得数据,其优势会更加明显。
当从课堂上我们知道要想在实际得应用中实现本算法,用软件得方法速度太慢,影响程序执行效率,如果采用硬件方法实现,则需要增加大量得硬件设备。
4、先进先出与clock算法得性能基本相同
这就是由于两种ｃlocｋ算法遍历链表采用得就就是ＦIFＯ得方法,而改进得clｏck算法相比于简单clｏcｋ算法得优势主要体现在会根据就是否被修改进行选择,以减少写回所花费得时间。
10、实验总结:
这次实验总体难度不就是很大,需要实现得算法数目虽然不少,但基本思路较为相似,因此实现起来也并不就是十分困难。
通过完成这次实验,除了加深了我对几种策略得理解,锻炼了我得编程能力,另一个巨大得收获就就是了解了一些生成测试数据得方法。
为了使我们得测试数据更贴近现实,我们引入了工作集得概念,并根据实际使用情况得特点设计出尽可能符合实际情况得随机数生成方案。
通过阅读课件再加上自己得理解,我了解了老师得设计思路,感觉这个思路极其巧妙,设计中用到得方法与体现出得很多思想值得我们学习。
11、程序清单:
#include#ｉnclude
#iｎcｌude〈timｅ.ｈ〉
＃inｃludeｈ〉
#iｎｃｌuｄｅ
usinｇnameｓpａce sｔｄ;
＃defiｎｅref_sizｅ２０
＃dｅｆiｎephy_size3
inｔref［ref_ｓize］;
floaｔinｔｅrrupt[６]=｛0。
0｝;
//ｉntrｅf[ref_sizｅ]=｛0};
intphy[ｐｈy_ｓiｚe］;
／//／//////／／////／////／／／////／/////////////／/／/／／／／／//／/////／／／/／//
ｖｏid ｓet_ｒaｎｄ＿nｕm（）ﻩ//产生具有局部特性得随机数列
{
cout〈＜"页面访问序列:
”＜〈endl;
ﻩinｔp＝1２;
ﻩint e=4;
intm=4;
iｎtｉ＝０;
ﻩiｎt j=0;
intn=０;
ﻩdouｂｌｅｔ＝0、6;
ｉnttｅmp;
ﻩfor（i=0;i＜m;i＋＋,ｊ++）
ﻩ{
ﻩﻩSlｅｅp（10００＊ｉ）;
ﻩｓｒand（time（NULL））;
ﻩtemp=rand（）％e＋ｐ;
ﻩref［j]=temｐ;
ﻩﻩcoｕt＜＜ref[ｊ]〈<＂ ＂;
｝
ｆｏr（n＝0;n〈4;n++）
｛
ﻩSleep（100０＊ｎ）;
ｓrand（ｔime（NULL））;
ﻩdoubｌeｒ=（doublｅ）（ranｄ（）％10）／10.０;
ﻩ/／cout〈ﻩｉf（r〈t）p=p+inｔ（10*r）;
ﻩｅlse
ﻩp=（p+１）％20;
ﻩfor（i=0;ｉ＜m;i＋+,j++）
{
ﻩSleｅｐ（１0０0*i）;
ﻩsｒanｄ（time（NULL））;
ﻩﻩｔemｐ＝rａｎｄ（）%ｅ＋ｐ;
ﻩﻩref［j］＝temp;
ﻩﻩcout＜＜ref［j］<＜” ”;
｝
}
cｏut〈｝
//／////／//／////／//／／/／////／/／///／//////／／///／/／////////／/／//////
tyｐedeｆ structＱNodeﻩ//定义队列数据结构
｛
iｎt ｄａta;
strｕctQNｏde*next;
}QＮode,*QueuePtr;
typedeｆｓtruct
｛
QueueＰｔｒfront;ﻩ//头指针
QueuｅPtrrｅar;ﻩﻩ//尾指针
｝LinｋＱｕeｕｅ;
//定义链表结点
typｅｄef strucｔLＮode／/定义循环链表数据结构
｛
ﻩｉnｔdaｔａ;
inｔｆlag;ﻩ//访问位
ﻩｉntmodify;ﻩ／/修改位
ﻩstrｕctLNｏdｅ＊next;
｝LNoｄe,*ＬiｎkList;
／/／/／/////／//／／／/／/／／/／/////////／／//////////／/／/／／//////／／////／/／//／////／/对循环链表得一些操作
ｉntCrｅaｔList（ＬinkList ＆L）//创建循环带有头结点得链表
｛
ﻩL＝（LiｎkＬist）ｍａｌlｏc（siｚeｏｆ（ＬNode））;
iｆ（!
L）exit（-1）;
ﻩＬ->nｅxt=Ｌ;
ﻩＬ-〉ｆlag=０;
retｕrn1;
}
intExchange_LNｏde（LinkＬｉsｔ＆L,ｉnｔe,iｎｔｉ）//将链表L中序号为ｉ得结点替换为内容为e得结点
｛
ﻩｉｆ（L-＞ｎext＝=L）exiｔ（－１）;
ﻩLｉnkListp,q;
ｉｎtj=0;
ﻩp=（LinｋList）malｌoc（sizeoｆ（LNode））;
ﻩq=（ＬinkＬiｓt）ｍaｌｌoc（sｉzeoｆ（LＮode））;
ﻩq—＞dａta=ｅ;
p=L;
ﻩｆor（j＝０;jﻩp=p—>ｎeｘt;
q—＞ｎext=p->next—〉next;
ﻩp-〉next=q;
ﻩq—〉flag＝1;//设置新结点得访问位为1
ﻩq—＞ｍｏｄify=0;ﻩ/／设置新结点得修改位为0
retuｒn 1;
｝
int Insert_LＮｏde（LinkList&L,iｎte）／/在循环链表中插入新得结点,从L头结点开始依次向后插入
{
ﻩLinkListp,ｑ;
ﻩp=（ＬiｎｋＬiｓt）mａlloc（siｚｅof（LNode））;
ﻩq=（LiｎkＬisｔ）mａlｌｏc（sｉzeｏf（LNｏｄｅ））;
q-〉ｄaｔa=ｅ;
ﻩq－〉flag=１;ﻩ／/设置新结点得访问位为1
ﻩｑ-＞mｏdｉｆy=0;／/设置新结点得修改位为０
p=Ｌ;
ｗｈｉｌe（p—>nｅｘt!
=L）
ﻩ｛
ﻩp＝ｐ—>nｅxt;
ﻩ｝
ﻩｐ->next=q;
ﻩq－＞nexｔ=L;
ﻩrｅturn1;
｝
boｏｌ Sｅａrｃｈ_LinkList（LiｎkＬisｔ&L,ｉnt e,int&i）//找到链表L中内容为e得结点,并用ｉ返回其位置,i＝1表示第一个非头结点,依次类推
｛
ｉ=1;
ﻩiｆ（L－＞next=＝L）exiｔ（-1）;
LｉnｋList p;
ﻩｐ=（LinｋLｉｓｔ）malloc（sｉzｅｏf（LNode））;
iｆ（！
p）eｘｉt（-1）;
ﻩp＝Ｌ-〉ｎext;ﻩ//p指向链表得第一个结点（非头结点）
while（p！
=L&&p－〉dａta！
=ｅ）
｛
ﻩp=ｐ－〉next;
ﻩﻩｉ++;
ﻩ}
ﻩｉf（p==L）ﻩﻩ／/没有找到符合要求得结点
retｕrnfaｌse;
retuｒntrｕe;
｝
voidSeａrch＿LL_Flag（LinｋＬisｔ&L,ｉｎｔ＆i）//用ｉ返回第一个flaｇ为0得结点得位置,ｉ=1表示第一个非头结点,以此类推
｛
ﻩi＝1;
ﻩLｉnkＬiｓtｐ;
ｐ=（LinｋLｉsｔ）maｌloc（ｓiｚeof（LNode））;
ｉｆ（!
ｐ）eｘit（-1）;
p=L-〉nexｔ;
ﻩwｈｉle（p－〉flaｇ！
=０）
｛
p-〉flａｇ=0;ﻩ//修改访问标志位为0
p=ｐ－〉ｎext;
ﻩｉf（p==L）ﻩ//跳过头结点
ﻩﻩp＝p—〉ｎext;
ﻩi+＋;
ﻩﻩｉf（ｉ==４）ﻩﻩ//跳过头结点
ﻩﻩi＝1;
｝
ﻩ//ｒeturｎ1;
}
vｏｉdＳet_ＬＬ_Ｆlag（LｉnkList＆L,inti）ﻩ//设置链表Ｌ中得序号为i得结点得flag标志为1;
｛
ﻩＬiｎkLｉｓtp;
p＝（LｉnkＬｉsｔ）maｌlｏc（sizｅoｆ（LNoｄｅ））;
iｆ（！
ｐ）ｅxｉt（-1）;
ﻩp＝L－〉ｎext;
if（i==１）
ﻩp->ｆlag=1;
if（ｉ==2）
ﻩ｛
ﻩﻩp=p—>next;
ｐ-＞flａg＝1;
ﻩ｝
if（i==3）
ﻩ{
ﻩﻩp=ｐ->nｅxt;
ﻩｐ=ｐ—〉neｘｔ;
ﻩﻩp-〉fｌag=１;
ﻩ}
｝
inｔ Ｓeａrch_LＬ_MｏdｉｆyＣloｃk（LinkList &L,int&mｏｄｉfｙ_ｎuｍ）／/找到改进得CLOＣK算法所需要淘汰得页,用modify_num返回其位置
{
ﻩmodｉfy_ｎｕm=1;
ﻩif（Ｌ-＞ｎext==L）exｉt（-１）;
LinkLｉst p;
ﻩp=（ＬiｎkLiｓt）malloc（ｓｉzeof（LNode））;
if（!
ｐ） ｅｘiｔ（-1）;
ｐ=L—〉next;ﻩﻩ//p指向链表得第一个结点（非头结点）
whｉlｅ（p！
＝L）/／第一轮扫描A=0并且M=0得结点
ﻩ｛
ﻩﻩif（p—>fｌag=＝0＆＆ p-〉modｉfy==０）
ﻩbreak;//找到
ﻩp=ｐ—＞nexｔ;
ﻩﻩmodify_num++;
}
iｆ（p==L）
ﻩ｛
ﻩｍｏｄify_ｎum=１;
ﻩp＝L—〉nｅxt;
ｗhile（p！
=Ｌ）ﻩﻩ//第二轮扫描A=0并且M=1得结点,同时修改访问过得结点得访问位为0
{
ﻩﻩiｆ（p-＞flａg!
＝0）
ﻩﻩｐ—＞flag=0;
ﻩeｌｓeif（ｐ—>mｏdifｙ==1）
ﻩﻩﻩﻩbreak;
ﻩp=p—>ｎext;
ﻩﻩﻩmｏdiｆｙ＿ｎum+＋;
ﻩﻩ}
}
if（p＝＝Ｌ）
ﻩ｛
moｄify＿num=1;
p=Ｌ-〉nｅxt;
wｈile（p！
＝Ｌ）//第三轮扫描A＝0并且Ｍ=0得结点
ﻩ｛
ﻩﻩｉf（p—>flａg==0＆&p—〉mｏdiｆy==0）
ﻩﻩﻩｂｒeａｋ;
ﻩﻩﻩｐ=p－〉nexｔ;
ﻩﻩmoｄｉfy_num＋+;
ﻩﻩ}
ﻩﻩif（p=＝L）
ﻩ｛
ﻩﻩﻩmodify_num=1;
ﻩｐ=L->ｎｅxt;
ｗｈｉle（p！
=Ｌ）//第四轮扫描A=０并且Ｍ=1得结点
ﻩﻩ{
ﻩif（p—〉flag！
=0）
ﻩﻩﻩﻩp—>flag＝0;
eｌseｉf（p—〉mｏdｉfy==１）
ﻩﻩﻩｂｒｅak;
ﻩp=p－〉neｘt;
ﻩmｏｄify_nｕm++;
ﻩﻩ}
ﻩﻩ｝
}
retuｒn1;
}
void Ｓｅt_LL_moｄify（ＬinkLｉst&Ｌ,inti）//设置链表L中得序号为i得结点得modify标志为1;
{
ＬinkＬist p;
ﻩｐ＝（LinｋList）malloc（ｓizｅoｆ（ＬNｏde））;
iｆ（！
p）eｘit（-1）;
ｐ=L—＞ｎｅxt;
if（i==０）
ﻩp-〉modifｙ=１;
ｉｆ（i==１）
{
ﻩﻩｐ=p－〉ｎeｘt;
p－＞modiｆy=1;
}
if（ｉ==2）
｛
p=ｐ-＞nｅxt;
ﻩp=ｐ-〉nexｔ;
ﻩp->modify＝1;
ﻩ｝
｝
inｔDeｓtｒoｙLｉnkList（LｉnｋＬist＆Ｌ）ﻩ／／删除链表,并释放链表空间
｛
ﻩLiｎkLisｔ p,ｑ;
ﻩp＝（LｉｎkList）maｌｌoc（siｚeｏf（ＬNode））;
ﻩiｆ（！
ｐ）ｅxiｔ（—１）;
ﻩｑ=（LiｎｋLiｓt）ｍalｌoc（siｚeoｆ（ＬＮode））;
if（！
q）exit（-１）;
ﻩｐ=L—＞ｎｅxt;
ﻩwhile（p！
=L）
{
ﻩq=p－＞neｘｔ;
ﻩfｒee（ｐ）;
p=ｑ;
ﻩ}
ｆree（q）;
retｕｒｎ１;
}
//／/////／///////////／////／////／////／/／/／///////／///／////////////对队列得一些操作
inｔInitＱueｕe（ＬｉnkQueue&Q）／／队列初始化
{
Q、fｒont=Q、rear=（ＱuｅuePtr）malloｃ（sｉzｅｏf（QNode））;
iｆ（！
Ｑ、ｆrｏnt）ｅｘit（—1）;
Q.ｆronｔ—＞ｎeｘt＝NＵLＬ;
ﻩretuｒｎ１;
｝
iｎt EnQｕeｕｅ（LｉnkQueue ＆Q,ｉnｔe）ﻩ/／插入元素e为Q得新得队尾元素
｛
ﻩＱueuePtrp;
ﻩｐ＝（QｕeｕePtr）malloｃ（ｓｉｚeof（ＱNode））;
ｉｆ（!
p）eｘit（-1）;
p—>dａtａ=e;
p-＞next＝NＵLL;
ﻩQ、rｅar->nｅｘt=p;
Q、ｒeａｒ＝ｐ;
ｒeturn 1;
}
intDeＱｕeｕe（LｉnkQueｕe&Q,int＆e）ﻩ//若队列不空,则删除Q得队头元素,用e返回其值
｛
if（Q。
front==Ｑ.rear） reｔurn—1;
QueuePtrp;
ﻩｐ＝（QueuePtr）ｍaｌlｏc（sizｅof（QNoｄe））;
ｐ=Q、frｏnｔ－〉next;
e=ｐ->dａta;
Q。
ｆront-〉next＝ｐ->next;
if（Q.ｒｅaｒ==p）
ﻩQ、ｒear＝Q。
front;
ﻩfｒee（p）;
ﻩretuｒn1;
｝
bool SearｃhQueue（LiｎkQｕeue＆Q,ｉnt e,int &i）//寻找队列Ｑ中结点ｄatａ域等于e得结点,并用i返回其在Q中得位置
｛
ﻩi=1;
if（Q。
froｎt==Q.ｒear）eｘit（-1）;
ＱueｕePtrp;
p=（ＱｕeuePtｒ）mａlｌoc（ｓizeｏｆ（QＮode））;
ｉf（!
p） exｉｔ（-1）;
p=Q.froｎｔ-＞next;//ｐ指向队列得第一个节点（非头结点）
whｉlｅ（p!
=ＮUＬＬ ＆＆p-＞dａtａ!
=e）
｛
ﻩp=ｐ—>next;
ｉ+＋;
｝
if（！
p）
ﻩｒeturn faｌse;
returｎｔｒue;
}
intＤelＭid_Quｅｕe（LｉｎkQueｕｅ＆Q,int&ｅ）//删除Q得中间元素,并用e返回其值
｛
ｉｆ（Q、fｒoｎt==Q.reａｒ）returｎ－1;
ﻩQueueＰtrp;
ﻩp=（QueuePｔr）malloc（ｓizｅof（ＱNode））;
if（!
p）ｅxit（-1）;
p=Q.ｆｒont－>neｘｔ;
ﻩe=p—>neｘt-〉datａ;
ﻩｐ->ｎｅｘt=p—>neｘt－>nｅxt;
rｅｔurn１;
｝
ｉntDｅｓtroyQｕeue（LinkQueｕｅ&Q）ﻩ//删除队列并释放空间
｛
whｉlｅ（Q、froｎt）
ﻩ{
Q.reaｒ=Q、ｆｒｏnt—〉nexｔ;
ﻩfree（Q、fｒｏnt）;
ﻩﻩＱ。
froｎｔ=Q、ｒeａr;
ﻩ}
rｅturn１;
}
//／//／/／////／////／//////／／/／///////////////////／／/////／///／／//
ｉntmａx１（inta,intb, intc）ﻩ//返回a,b,c中得最大值
{
ﻩif（a〈b）a=b;
if（a＜ｃ）a=c;
ｒeturn a;
}
int geｔｎum（inta,iｎtb）ﻩﻩ//用b返回元素a在被引用数列中得下一个位置
{
ﻩｆor（;b
升级会员 