最佳置换算法c语言（最佳置换算法C语言） 大家并不陌生，借来给大家详细说说吧！

　　今天给各位分享最佳置换算法c语言的知识，其中也会对最佳置换算法C语言进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

　　本文目录一览：

　　1、计算机操作系统中页面置换的三种方式？

2、c语言编写页面置换算法

3、C语言模拟FIFO算法，随机生成320条指令，有四块物理块，为什么错了？

4、OPT页面置换算法最优性证明。

5、怎样用C语言编写简单的FIFO置换算法

6、操作系统课程设计，用C#实现内存页面的置换。实现算法间比较

　　计算机操作系统中页面置换的三种方式？

　　常见的置换算法有：

　　1．最佳置换算法（OPT）（理想置换算法）

　　2．先进先出置换算法（FIFO）：

　　3．最近最久未使用（LRU）算法

　　4．Clock置换算法（LRU算法的近似实现）

　　5．最少使用（LFU）置换算法

　　6．工作集算法

　　7 . 工作集时钟算法

　　8. 老化算法（非常类似LRU的有效算法）

　　9. NRU(最近未使用）算法

　　10. 第二次机会算法

　　c语言编写页面置换算法

　　//熬夜弄出来的，记得加分哦

　　#includestdio.h

　　void Print(int bc[],int blockCount)

　　{

　　for(int i=0;iblockCount;i++)

　　{

　　printf(“%d “,bc[i]);

　　}

　　printf(“

　　”);

　　}

　　bool Travel(int bc[],int blockCount,int x)

　　{

　　bool is_found=false;

　　int i;

　　for(i=0;iblockCount;i++)

　　{

　　if(bc[i]==x)

　　{

　　is_found=true;

　　break;

　　}

　　}

　　return is_found;

　　}

　　void FIFO(int pc[],int bc[],int pageCount,int blockCount)

　　{

　　printf(“0：FIFO置换算法

　　”);

　　int i;

　　if(pageCount=blockCount)

　　{

　　printf(“缺页次数为0

　　”);

　　printf(“缺页率为0

　　”);

　　}

　　else

　　{

　　int noPage=0;

　　int p=0;

　　for(i=0;ipageCount;i++)

　　{

　　//printf(“引用页：%d

　　”,pc[i]);

　　if(!Travel(bc,blockCount,pc[i]))

　　{

　　if(iblockCount)

　　{

　　bc[i]=pc[i];

　　}

　　else

　　{

　　if(p==blockCount)

　　{

　　p=0;

　　}

　　bc[p]=pc[i];

　　p++;

　　}

　　noPage++;

　　//printf(“物理块情况：

　　”);

　　//Print(bc,blockCount);

　　}

　　//printf(“

　　”);

　　}

　　printf(“FIFO缺页次数为:%d

　　”,noPage);

　　printf(“FIFO缺页率为:%.2f%%

　　”,(float)noPage/pageCount*100);

　　}

　　}

　　int FoundMaxNum(int a[],int n)

　　{

　　int k,j;

　　k=a[0];

　　j=0;

　　for (int i=0;in;i++)

　　{

　　if(a[i]=k)

　　{

　　k=a[i];

　　j=i;

　　}

　　}

　　return j;

　　}

　　void LRU(int pc[],int bc[],int pageCount,int blockCount)

　　{

　　printf(“1：LRU置换算法

　　”);

　　if(pageCount=blockCount)

　　{

　　printf(“缺页次数为0

　　”);

　　printf(“缺页率为0

　　”);

　　}

　　else

　　{

　　int noPage=0;

　　int i,j,m;

　　int bc1[100];

　　for(i=0;iblockCount;i++)

　　{

　　bc1[i]=0;

　　}

　　for(i=0;ipageCount;i++)

　　{

　　// printf(“引用页：%d

　　”,pc[i]);

　　if(!Travel(bc,blockCount,pc[i]))

　　{

　　if(iblockCount)

　　{

　　bc[i]=pc[i];

　　for(int p=0;p=i;p++)

　　{

　　bc1[p]++;

　　}

　　}

　　else

　　{

　　for(j=0;jblockCount;j++)

　　{

　　bc1[j]++;

　　}

　　int k=FoundMaxNum(bc1,blockCount);

　　bc[k]=pc[i];

　　bc1[k]=1;

　　}

　　noPage++;

　　//printf(“物理快情况：

　　”);

　　//Print(bc,blockCount);

　　}

　　else if(Travel(bc,blockCount,pc[i]))

　　{

　　if(iblockCount)

　　{

　　for(j=0;j=i;j++)

　　{

　　bc1[j]++;

　　}

　　for(m=0;m=i;m++)

　　{

　　if(bc[m]==pc[i])

　　{

　　break;

　　}

　　}

　　bc1[m]=1;

　　bc[m]=pc[i];

　　}

　　else

　　{

　　for(j=0;jblockCount;j++)

　　{

　　bc1[j]++;

　　}

　　for(m=0;mblockCount;m++)

　　{

　　if(bc[m]==pc[i])

　　{

　　break;

　　}

　　}

　　bc1[m]=1;

　　bc[m]=pc[i];

　　}

　　}

　　//printf(“

　　”);

　　}

　　printf(“LRU缺页次数为:%d

　　”,noPage);

　　printf(“LRU缺页率为:%.2f%%

　　”,(float)noPage/pageCount*100);

　　}

　　}

　　void Optiomal(int pc[],int bc[],int pageCount,int blockCount)

　　{

　　printf(“2：最佳置换算法

　　”);

　　if(pageCount=blockCount)

　　{

　　printf(“缺页次数为0

　　”);

　　printf(“缺页率为0

　　”);

　　}

　　else

　　{

　　int noPage=0;

　　int i,j,k;

　　for(i=0;ipageCount;i++)

　　{

　　// printf(“引用页：%d

　　”,pc[i]);

　　if(!Travel(bc,blockCount,pc[i]))

　　{

　　if(iblockCount)

　　{

　　bc[i]=pc[i];

　　}

　　else

　　{

　　int max=0;

　　int blockIndex;;

　　for(j=0;jblockCount;j++)

　　{

　　for(k=i;kpageCount;k++)

　　{

　　if(bc[j]==pc[k])

　　{

　　break;

　　}

　　}

　　if(k=max)

　　{

　　max=k;

　　blockIndex=j;

　　}

　　}

　　bc[blockIndex]=pc[i];

　　}

　　noPage++;

　　//printf(“物理快情况：

　　”);

　　//Print(bc,blockCount);

　　}

　　//printf(“

　　”);

　　}

　　printf(“OPT缺页次数为:%d

　　”,noPage);

　　printf(“OPT缺页率为:%.2f%%

　　”,(float)noPage/pageCount*100);

　　}

　　}

　　int main()

　　{

　　int pageCount,blockCount,i,pc[100];

　　printf(“输入页面数

　　”);

　　scanf(“%d”,pageCount);

　　printf(“输入页面走向

　　”);

　　for(i=0;ipageCount;i++)

　　{

　　scanf(“%d”,pc[i]);

　　}

　　blockCount=3;//物理块数

　　int bc1[100];

　　printf(“

　　”);

　　FIFO(pc,bc1,pageCount,blockCount);

　　int bc2[100];

　　printf(“

　　”);

　　LRU(pc,bc2,pageCount,blockCount);

　　int bc3[100];

　　printf(“

　　”);

　　Optiomal(pc,bc3,pageCount,blockCount);

　　return 0;

　　}

　　C语言模拟FIFO算法，随机生成320条指令，有四块物理块，为什么错了？

　　这可是hen宝贵的啊

　　#include

　　#include

　　#include

　　#include

　　#define Bsize 4

　　typedef struct BLOCK//声明一种新类型——物理块类型

　　{

　　int pagenum;//页号

　　int accessed;//访问字段，其值表示多久未被访问

　　}BLOCK;

　　int pc;//程序计数器，用来记录指令的序号

　　int n;//缺页计数器，用来记录缺页的次数

　　static int temp[320];//用来存储320条随机数

　　BLOCK block[Bsize]; //定义一大小为4的物理块数组

　　//*************************************************************

　　void init( ); //程序初始化函数

　　int findExist(int curpage);//查找物理块中是否有该页面

　　int findSpace( );//查找是否有空闲物理块

　　int findReplace( );//查找应予置换的页面

　　void display ( );//显示

　　void suijishu( );//产生320条随机数,显示并存储到temp[320]

　　void pagestring( );//显示调用的页面队列

　　void OPT( );//OPT算法

　　void LRU( );// LRU算法

　　void FIFO( );//FIFO算法

　　//*************************************************************

　　void init( )

　　{

　　for(int i=0;iBsize;i++)

　　{

　　block[i].pagenum=-1;

　　block[i].accessed=0;

　　pc=n=0;

　　}

　　}

　　//————————————————————-

　　int findExist(int curpage)

　　{

　　for(int i=0; iBsize; i++)

　　{

　　if(block[i].pagenum == curpage )

　　return i;//检测到内存中有该页面，返回block中的位置

　　}

　　return -1;

　　}

　　//————————————————————-

　　int findSpace( )

　　{

　　for(int i=0; iBsize; i++)

　　{

　　if(block[i].pagenum == -1)

　　return i;//找到空闲的block，返回block中的位置

　　}

　　return -1;

　　}

　　//————————————————————-

　　int findReplace( )

　　{

　　int pos = 0;

　　for(int i=0; iBsize; i++)

　　{

　　if(block[i].accessed block[pos].accessed)

　　pos = i;//找到应予置换页面，返回BLOCK中位置

　　}

　　return pos;

　　}

　　//————————————————————-

　　void display( )

　　{

　　for(int i=0; iBsize; i++)

　　{

　　if(block[i].pagenum != -1)

　　{ printf(” %02d”,block[i].pagenum);}

　　}

　　coutendl;

　　}

　　//————————————————————-

　　void suijishu( )

　　{ int flag=0;

　　cinpc;

　　cout”******按照要求产生的320个随机数：*******”endl;

　　for(int i=0;i320;i++)

　　{

　　temp[i]=pc;

　　if(flag%2==0) pc=++pc%320;

　　if(flag==1) pc=rand( )% (pc-1);

　　if(flag==3) pc=pc+1+(rand( )%(320-(pc+1)));

　　flag=++flag%4;

　　printf(” %03d”,temp[i]);

　　if((i+1)%10==0) coutendl;

　　}

　　}

　　//————————————————————-

　　void pagestring( )

　　{

　　for(int i=0;i320;i++)

　　{

　　printf(” %02d”,temp[i]/10);

　　if((i+1)%10==0) coutendl;

　　}

　　}

　　//————————————————————-

　　void OPT( )

　　{

　　int exist,space,position ;

　　int curpage;

　　for(int i=0;i320;i++)

　　{

　　if(i%100==0) getch( );

　　pc=temp[i];

　　curpage=pc/10;

　　exist = findExist(curpage);

　　if(exist==-1)

　　{

　　space = findSpace ( );

　　if(space != -1)

　　{

　　block[space].pagenum = curpage;

　　display( );

　　n=n+1;

　　}

　　else

　　{

　　for(int k=0;kBsize;k++)

　　{

　　for(int j=i;j320;j++)

　　{

　　if(block[k].pagenum!= temp[j]/10)

　　{

　　block[k].accessed = 1000;

　　}//将来不会用，设置为一个很大数

　　else

　　{

　　block[k].accessed = j;

　　break;

　　}

　　}

　　}

　　position = findReplace( );

　　block[position].pagenum = curpage;

　　display( );

　　n++;

　　}

　　}

　　}

　　cout”缺页次数:”nendl;

　　cout”缺页率:”(n/320.0)*100″%”endl;

　　}

　　//————————————————————-

　　void LRU( )

　　{

　　int exist,space,position ;

　　int curpage;

　　for(int i=0;i320;i++)

　　{

　　if(i%100==0) getch( );

　　pc=temp[i];

　　curpage=pc/10;

　　exist = findExist(curpage);

　　if(exist==-1)

　　{

　　space = findSpace( );

　　if(space != -1)

　　{

　　block[space].pagenum = curpage;

　　display( );

　　n=n+1;

　　}

　　else

　　{

　　position = findReplace( );

　　block[position].pagenum = curpage;

　　display( );

　　n++;

　　}

　　}

　　else block[exist].accessed = -1;//恢复存在的并刚访问过的BLOCK中页面accessed为-1

　　for(int j=0; j4; j++)

　　{block[j].accessed++;}

　　}

　　cout”缺页次数:”nendl;

　　cout”缺页率:”(n/320.0)*100″%”endl;

　　}

　　//————————————————————-

　　void FIFO( )

　　{

　　int exist,space,position ;

　　int curpage;

　　for(int i=0;i320;i++)

　　{

　　if(i%100==0) getch( );

　　pc=temp[i];

　　curpage=pc/10;

　　exist = findExist(curpage);

　　if(exist==-1)

　　{

　　space = findSpace( );

　　if(space != -1)

　　{

　　block[space].pagenum = curpage;

　　display( );

　　n=n+1;

　　}

　　else

　　{

　　position = findReplace( );

　　block[position].pagenum = curpage;

　　display( );

　　n++;

　　block[position].accessed–;

　　}

　　}

　　for(int j=0; jBsize; j++)

　　block[j].accessed++;

　　}

　　cout”缺页次数:”nendl;

　　cout”缺页率:”(n/320.0)*100″%”endl;

　　}

　　//*************************************************************

　　void main( )

　　{

　　int select;

　　cout”请输入第一条指令号(0~320)：”;

　　suijishu( );

　　cout”*****对应的调用页面队列*******”endl;

　　pagestring( );

　　do

　　{

　　cout”****************************************”endl;

　　cout”——1:OPT 2:LRU 3:FIFO 4:退出—–“endl;

　　cout”****************************************”endl;

　　cout” 请选择一种页面置换算法:”;

　　cinselect;

　　cout”****************************************”endl;

　　init( );

　　switch(select)

　　{

　　case 1:cout”最佳置换算法OPT:”endl;

　　cout”*****************”endl;

　　OPT( );

　　break;

　　case 2:cout”最近最久未使用置换算法LRU:”endl;

　　cout”**************************”endl;

　　LRU( );

　　break;

　　case 3:cout”先进先出置换算法FIFO:”endl;

　　cout”*********************”endl;

　　FIFO( );

　　break;

　　default: ;

　　}

　　}while(select!=4);

　　}

　　你试试可以不，应该没问题的

　　要注意这是用C++编写的，你改一下就可以用了

　　OPT页面置换算法最优性证明。

　　1常见的置换算法

　　1．最佳置换算法（OPT）（理想置换算法）：所选择的被淘汰页面将是以后永不使用的，或者是在最长时间内不再被访问的页面，这样可以保证获得最低的缺页率。2．先进先出置换算法（FIFO）：优先淘汰最早进入的页面，亦即在内存中驻留时间最久的页面。3．最近最久未使用（LRU）算法：选择最近最长时间未访问过的页面予以淘汰。4．Clock置换算法（LRU算法的近似实现）：给每一帧关联一个附加位，称为使用位。5．最少使用（LFU）置换算法6．工作集算法7 . 工作集时钟算法8. 老化算法（非常类似LRU的有效算法）9. NRU(最近未使用）算法10. 第二次机会算法2操作系统页面置换算法代码#include stdio.h[1]#include stdlib.h#include unistd.h #define TRUE 1#define FALSE 0#define INVALID -1#define NUL 0#define total_instruction 320 /*指令流长*/#define total_vp 32 /*虚页长*/#define clear_period 50 /*清零周期*/typedef struct{ /*页面结构*/int pn,pfn,counter,time;}pl_type;pl_type pl[total_vp]; /*页面结构数组*/struct pfc_struct{ /*页面控制结构*/int pn,pfn;struct pfc_struct *next;};typedef struct pfc_struct pfc_type;pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;int diseffect,a[total_instruction];int page[total_instruction], offset[total_instruction];void initialize(int);void FIFO(int);void LRU(int);void NUR(int);int main(){int S,i;srand((int)getpid());S=(int)rand()%390;for(i=0;itotal_instruction;i+=1) /*产生指令队列*/{a[i]=S; /*任选一指令访问点*/a[i+1]=a[i]+1; /*顺序执行一条指令*/a[i+2]=(int)rand()%390; /*执行前地址指令m’*/a[i+3]=a[i+2]+1; /*执行后地址指令*/S=(int)rand()%390;}for(i=0;itotal_instruction;i++) /*将指令序列变换成页地址流*/{page[i]=a[i]/10;offset[i]=a[i]%10;}for(i=4;i=32;i++) /*用户内存工作区从4个页面到32个页面*/{printf(“%2d page frames”,i);FIFO(i);LRU(i);NUR(i);printf(“

　　”);}return 0;}void FIFO(int total_pf) /*FIFO(First in First out)ALGORITHM*//*用户进程的内存页面数*/{int i;pfc_type *p, *t;initialize(total_pf); /*初始化相关页面控制用数据结构*/busypf_head=busypf_tail=NUL; /*忙页面队列头，对列尾链接*/for(i=0;itotal_instruction;i++){if(pl[page[i]].pfn==INVALID) /*页面失效*/{diseffect+=1; /*失效次数*/if(freepf_head==NUL) /*无空闲页面*/{p=busypf_head-next;pl[busypf_head-pn].pfn=INVALID; /*释放忙页面队列中的第一个页面*/freepf_head=busypf_head;freepf_head-next=NUL;busypf_head=p;}p=freepf_head-next; /*按方式调新页面入内存页面*/freepf_head-next=NUL;freepf_head-pn=page[i];pl[page[i]].pfn=freepf_head-pfn;if(busypf_tail==NUL)busypf_head=busypf_tail=freepf_head;else{busypf_tail-next=freepf_head;busypf_tail=freepf_head;}freepf_head=p;}}printf(“FIFO:%6.4F”,1-(float)diseffect/320);}void LRU(int total_pf){int min,minj,i,j,present_time;initialize(total_pf);present_time=0;for(i=0;itotal_instruction;i++){if(pl[page[i]].pfn==INVALID) /*页面失效*/{diseffect++;if(freepf_head==NUL) /*无空闲页面*/{min=32767;for(j=0;jtotal_vp;j++)if(minpl[j].timepl[j].pfn!=INVALID){min=pl[j].time;minj=j;}freepf_head=pfc[pl[minj].pfn];pl[minj].pfn=INVALID;pl[minj].time=-1;freepf_head-next=NUL;}pl[page[i]].pfn=freepf_head-pfn;pl[page[i]].time=present_time;freepf_head=freepf_head-next;}elsepl[page[i]].time=present_time;present_time++;}printf(“LRU:%6.4f”,1-(float)diseffect/320);}void NUR(int total_pf){int i,j,dp,cont_flag,old_dp;pfc_type *t;initialize(total_pf);dp=0;for(i=0;itotal_instruction;i++){if(pl[page[i]].pfn==INVALID) /*页面失效*/{diseffect++;if(freepf_head==NUL) /*无空闲页面*/{cont_flag=TRUE;old_dp=dp;while(cont_flag)if(pl[dp].counter==0pl[dp].pfn!=INVALID)cont_flag=FALSE;else{dp++;if(dp==total_vp)dp=0;if(dp==old_dp)for(j=0;jtotal_vp;j++)pl[j].counter=0;}freepf_head=pfc[pl[dp].pfn];pl[dp].pfn=INVALID;freepf_head-next=NUL;}pl[page[i]].pfn=freepf_head-pfn;freepf_head=freepf_head-next;}elsepl[page[i]].counter=1;if(i%clear_period==0)for(j=0;jtotal_vp;j++)pl[j].counter=0;}printf(“NUR:%6.4f”,1-(float)diseffect/320);}void initialize(int total_pf) /*初始化相关数据结构*//*用户进程的内存页面数*/{int i;diseffect=0;for(i=0;itotal_vp;i++){pl[i].pn=i;pl[i].pfn=INVALID; /*置页面控制结构中的页号，页面为空*/pl[i].counter=0;pl[i].time=-1; /*页面控制结构中的访问次数为0，时间为-1*/}for(i=1;itotal_pf;i++){pfc[i-1].next=pfc[i];pfc[i-1].pfn=i-1;/*建立pfc[i-1]和pfc[i]之间的连接*/}pfc[total_pf-1].next=NUL;pfc[total_pf-1].pfn=total_pf-1;freepf_head=pfc[0]; /*页面队列的头指针为pfc[0]*/}/*说明：本程序在Linux的gcc下和c-free下编译运行通过*/【】

　　不知道能不能打开-是复制的 但也辛苦半天 忘采纳~

　　怎样用C语言编写简单的FIFO置换算法

　　#include “stdio.h”

　　#include “malloc.h”

　　#define OK 1

　　#define ERROR 0

　　#define NULL 0

　　#define status int

　　typedef int Elemtype;

　　/*这个定义的是队列的元素的数据结构*/

　　typedef struct tailDATA{

　　Elemtype data;/*这个存放的是队列元素的值*/

　　struct tailDATA *next;//指向下一个元素

　　}datatail,*map;

　　/*以下定义的是队列头的数据结构*/

　　typedef struct Tail{

　　/*说明:对队列进行操作的时候,插入的时候是对front操作,删除*/

　　Elemtype data;/*这个记载的是队列的元素的个数*/

　　map front;/*这个是队列的头*/

　　map rear;/*这个是队列的尾*/

　　}tail,*mappath;

　　/*以下定义的就是操作了,初始话的操作就不想做了,直接写个插入和删除等的一些的算法就可以了*/

　　status inserttail(mappath T,map P)

　　{/*这个函数的功能是将一个个已知的元素插入队列中*/

　　if(T==NULL)

　　{

　　T=(mappath)malloc(sizeof(tail));

　　T-data=0;

　　T-front=NULL;

　　T-rear=NULL;

　　}

　　if(!P) return OK;

　　T-rear-next=P;

　　T-rear=P;

　　if(!(T-front)) T-front=P;

　　return OK;

　　}

　　status insertdatatail(mappath T,int a)

　　{/*这个函数将一个元素插入队列中,其实这个函数是没有必要的,但是为了方便起见,还是写了个*/

　　if(T==NULL)

　　{

　　T=(mappath)malloc(sizeof(tail));

　　T-data=0;

　　T-front=NULL;

　　T-rear=NULL;

　　map linshi=(map)malloc(sizeof(datatail));

　　linshi-data=a;

　　linshi-next=NULL;

　　T-front=linshi;

　　T-rear=linshi;

　　T-data=1;

　　return OK;

　　}

　　map linshi=(map)malloc(sizeof(datatail));

　　linshi-data=a;

　　linshi-next=NULL;

　　T-rear-next=linshi;

　　T-rear=linshi;

　　if(!(T-front)) T-front=linshi;

　　T-data++;

　　return OK;

　　}

　　status deltail(mappath T)

　　{/*因为对队列进行删除操作的时候,基本上是没有什么条件,就是对front做一些相应的操作就可以了

　　,所以他的函数列表也就比较少了*/

　　if(!T) return ERROR;/*如果队列本来就是空的,那么就返回一个错误的信息*/

　　if(T-front==T-rear)

　　{/*如果队列只有一个元素,就执行下面的操作,防止出现了错误*/

　　map linshi=T-front;

　　free(linshi);

　　T-data=0;

　　T-front=NULL;

　　T-rear=NULL;

　　return OK;

　　}

　　map linshi=T-front;

　　T-front=T-front-next;

　　T-data–;

　　free(linshi);

　　return OK;

　　}

　　status puttail(mappath T)

　　{/*这个是对一个已经存在的队列进行输出*/

　　if(!T) return ERROR;

　　printf(“the tail’count is %d

　　”,T-data);

　　int count=T-data;map q=T-front;

　　for(int i=0;icount;i++)

　　{

　　printf(“%d “,q-data);

　　q=q-next;

　　}

　　return OK;

　　}

　　int main()

　　{

　　printf(“hello,world!

　　”);

　　mappath q=NULL;int count1=0;int dataa=0;

　　printf(“please input a number to the count of tail

　　”);

　　scanf(“%d”,count1);

　　for(int i=0;icount1;i++)

　　{

　　printf(“please input a number to tail

　　”);

　　scanf(“%d”,dataa);

　　insertdatatail(q,dataa);

　　}

　　puttail(q);

　　deltail(q);

　　puttail(q);

　　return 0;

　　}

　　操作系统课程设计，用C#实现内存页面的置换。实现算法间比较

　　页面置换算法

　　一．题目要求：

　　通过实现页面置换算法的FIFO和LRU两种算法，理解进程运行时系统是怎样选择换出页面的，对于两种不同的算法各自的优缺点是哪些。

　　要求设计主界面以灵活选择某算法，且以下算法都要实现 1) 最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。

　　2) 先进先出算法(FIFO)：淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

　　3) 最近最久未使用算法(LRU)：淘汰最近最久未被使用的页面。 4) 最不经常使用算法(LFU) 二．实验目的：

　　1、用C语言编写OPT、FIFO、LRU，LFU四种置换算法。 2、熟悉内存分页管理策略。 3、了解页面置换的算法。 4、掌握一般常用的调度算法。 5、根据方案使算法得以模拟实现。 6、锻炼知识的运用能力和实践能力。 三、设计要求

　　1、编写算法，实现页面置换算法FIFO、LRU；

　　2、针对内存地址引用串，运行页面置换算法进行页面置换； 3、算法所需的各种参数由输入产生（手工输入或者随机数产生）； 4、输出内存驻留的页面集合，页错误次数以及页错误率；

　　四．相关知识：

　　1．虚拟存储器的引入：

　　局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。

　　2．虚拟存储器的定义：

　　虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。

　　3．虚拟存储器的实现方式：

　　分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。

　　请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。

　　4．页面分配：

　　平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。 按比例分配算法，根据进程的大小按比例分配物理块。

　　考虑优先的分配算法，把内存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。

　　5．页面置换算法：

　　常用的页面置换算法有OPT、FIFO、LRU、Clock、LFU、PBA等。 五、设计说明

　　1、采用数组页面的页号

　　2、FIFO算法，选择在内存中驻留时间最久的页面予以淘汰；

　　分配n个物理块给进程，运行时先把前n个不同页面一起装入内存，然后再从后面逐一比较，输出页面及页错误数和页错误率。

　　3、LRU算法，根据页面调入内存后的使用情况进行决策；

　　同样分配n个物理块给进程，前n个不同页面一起装入内存，后面步骤与前一算法类似。

　　选择置换算法，先输入所有页面号，为系统分配物理块，依次进行置换： 六．设计思想：

　　OPT基本思想：

　　是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。数组next[mSIZE]记录物理块中对应页面的最后访问时间。每当发生缺页时，就从物理块中找出最后访问时间最大的页面，调出该页，换入所缺的页面。

　　FIFO基本思想：

　　是用队列存储内存中的页面，队列的特点是先进先出，与该算法是一致的，所以每当发生缺页时，就从队头删除一页，而从队尾加入缺页。或者借助辅助数组time[mSIZE]记录物理块中对应页面的进入时间，每次需要置换时换出进入时间最小的页面。

　　LRU基本思想：

　　是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。数组flag[10]标记页面的访问时间。每当使用页面时，刷新访问时间。发生缺页时，就从物理块中页面标记最小的一页，调出该页，换入所缺的页面。 七．流程图：

　　如下页所示

　　六．运行结果： 1. 按任意键进行初始化：

　　2. 载入数据：

　　3. 进入置换算法选择界面：

　　4.运算中延迟操作：

　　5.三种算法演示结果：

　　关于最佳置换算法c语言和最佳置换算法C语言的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。

最后，我要感谢所有支持和关注嗨壳技术分享网（www.heikehao.com）的人们，是你们的支持和鼓励使我们更加坚定了创办这个平台的决心。我们将致力于为大家提供更好的内容和服务，为技术爱好者们搭建一个学习、分享和进步的家园。