页面调度算法
黑工程操作系统复习题
1. LRU 页面调度算法总是选择在主存驻留时间最长的页面被淘汰。
（）2. 磁盘是共享设备，所以每一时刻可有若干个进程同时与它交换信息。
（）3. 分时系统中，时间片设置得越小，则平均响应时间越短。
（）4. 多个进程可以对应于同一个程序，且一个进程也可能会执行多个程序。
（）5. 设备独立性是指系统具有使用不同设备的能力。
（）6. 进程A、B共享变量x，需要互斥执行；进程B C共享变量y, B、C也需要互斥执行，因此，进程A、C必须互斥执行。
（）7. 为了提高系统资源的利用率，在作业调度的优先级算法中应该规定，计算型作业的优先级较高，I/O 型作业的优先级较低。
（）8.I/0 交通管理程序的主要功能是管理主存控制器和通道。
（）9. 引入缓冲区能使CPU和I/O设备之间速度不匹配的情况得到改善，但并不能减少设备中断CPU的次数。
（）10. 由于设备驱动程序与硬件紧密相关，因此，系统中配备多少个设备就必须配置同样数量的设备驱动程序。
（）11. 可以将操作系统看作是一个资源分配器，用来控制I/O 设备和用户的程序。
（）12. 死锁的形成只与资源分配策略有关，而与并发进程的执行速度无关。
（）13. 在引入线程的操作系统中，线程是资源分配和调度的基本单位。
（）14. 分页存储管理方案易于实现用户使用内存空间的动态扩充。
（）15. 对临界资源应采取互斥访问方式来实现共享。
（）1. 错，原因: 是选择最长时间没有被用的页面被淘汰。
2. 错，原因: 每一时刻只有一个进程与它交换信息。
3. 错，原因：平均响应时间不但与时间片的大小有关，还与其他因素有关。
4. 对5. 错，原因：设备独立性，可使应用程序独立于具体的物理设备和独立于设备的类型6. 错，原因:不传递。
7. 错，原因:I/O 型作业的优先级高。
8. 错，原因:I/O 交通管理程序的主要功能是管理设备、控制器和通道。
9. 错，减少设备中断CPU的次数。
10. 错，一类一种。
opt页面调度算法
opt页面调度算法调度算法是操作系统中的一个重要概念，它指的是如何合理地安排和管理进程的执行顺序，以提高系统的效率和公平性。
在操作系统中，OPT算法是一种常用的页面调度算法，用于解决内存分页管理中的页面置换问题。
页面置换问题是指当物理内存不足以容纳所有需要运行的进程时，操作系统需要将内存中的一些页面置换出去，以便为新的页面腾出空间。
OPT算法就是一种基于最佳置换策略的页面调度算法，它的思想是选择合适时机将最长时间内没有被访问的页面置换出去。
OPT算法的核心思想是基于未来的页面访问情况进行决策，即它会根据对未来页面访问情况的最优预测来置换页面。
具体来说，OPT算法会根据进程访问页面的历史记录，预测未来一段时间内可能会访问的页面，然后选择最长时间内没有被访问的页面进行置换。
OPT算法的实现步骤如下：1.首先，根据进程的页面访问历史记录，预测未来一段时间内可能会被访问的页面。
可以使用一些算法或者统计方法来进行预测，如最大似然估计、贝叶斯网络等。
2.然后，根据对未来页面访问情况的预测，计算出每个页面在未来一段时间内被访问的时间间隔。
3.接下来，选择最长时间内没有被访问的页面进行置换。
即选择在未来一段时间内最长时间没有被访问的页面进行置换。
4.最后，将选择的页面从物理内存中置换出去，为新的页面腾出空间。
OPT算法的优点是可以最大程度上减少页面置换的次数，提高系统的性能。
因为它基于最佳置换策略，能够合理地预测未来页面的访问情况，选择最长时间没有被访问的页面进行置换，从而减少了页面置换的频率。
然而，OPT算法也存在一些问题。
首先，它需要准确地预测未来页面的访问情况，这对于实际应用来说是非常困难的，因为页面访问情况往往是不确定的，会受到各种因素的影响。
其次，OPT算法的实现依赖于进程的页面访问历史记录，而获取和存储进程的页面访问历史记录是一项耗费资源的任务。
综上所述，OPT算法是一种常用的页面调度算法，它通过基于最佳置换策略来进行页面置换，从而减少页面置换的次数，提高系统性能。
页面调度问题
一、问题描述假设有n个页面驻留在内存中，且有一个能容纳k个页面的高速缓存。
现有依次访问内存中m个页面的请求序列I=I1,I2,…,I i,…,I m，其中m>k。
我们必须确定任何时刻哪k个页面放在高速缓存中。
对某个访问请求I i，若该页面在高速缓存中，则可很快完成访问。
否则发生一次缺页，必须将其调入高速缓存。
这时，若高速缓存未满，则直接将其调入，否则必须确定将高速缓存中哪个页面置换出来以便为I i腾出空间。
高速缓存调度问题是指如何调度页面使得缺页的总数尽可能少。
二、算法分析页面调度策略可以分为两类：一类是基于进程驻留集大小不变的策略；另一类基于进程驻留集可变策略。
在本问题中，驻留集大小是固定的，所以只能采用进程驻留集大小不变的策略。
由于页面调度根程序的执行有关，所以没有最优解，只能得到一般的结论。
在本题中，我采用的是多种贪心策略，不同的贪心策略得到的结果不同，不同的输入对结果也有较大的影响。
驻留集不变的策略中共同的是驻留集大小不变。
若设k为驻留集的大小，(+t s为时刻t的驻留集，)(t)1r为时刻t访问的页号（t是以访问串的每一项为单位的时间），如访问串为1，4，5，即时刻1访问第1页，时刻2访问第4页，时刻3访问第5页，则记为1=r)2(=r。
驻留集大小)1(=)3(,4r，5=)0(s固定的替换策略有如下控制过程。
空集⎪⎩⎪⎨⎧-++++=+}{)}1({)()}1({)()()1(y t r t s t r t s t s t s )1(,|)(|),1()1(|)(|),1()1()1()1(+∈=+∉+<+∉++∈+t s y m t s t s t r m t s t s t r t s t r式中y 为被替换页。
根据不同的选择y 的方法可形成不同策略。
我在做本题过程中，每个算法都是先将页面访问的前几个页面填入驻留集中，接下来再看其他的页是否需要替换。
没有计算空驻留集情况下的页面调度的缺页情况。
页面调度实验报告
一、实验内容（1）页面调度算法目前有许多页面调度算法，本实验主要涉及先进先出调度算法、最近最少调度算法、最近最不常用调度算法。
本实验使用页面调度算法时作如下假设，进程在创建时由操作系统为之分配一个固定数目物理页，执行过程中物理页的数目和位置不会改变。
也即进程进行页面调度时只能在分到的几个物理页中进行。
下面对各调度算法的思想作一介绍。
<1> 先进先出调度算法先进先出调度算法根据页面进入内存的时间先后选择淘汰页面，先进入内存的页面先淘汰，后进入内存的后淘汰。
本算法实现时需要将页面按进入内存的时间先后组成一个队列，每次调度队首页面予以淘汰。
<2>最近最少调度算法先进先出调度算法没有考虑页面的使用情况，大多数情况下性能不佳。
根据程序执行的局部性特点，程序一旦访问了某些代码和数据，则在一段时间内会经常访问他们，因此最近最少用调度在选择淘汰页面时会考虑页面最近的使用，总是选择在最近一段时间以来最少使用的页面予以淘汰。
算法实现时需要为每个页面设置数据结构记录页面自上次访问以来所经历的时间。
<3>最近最不常用调度算法由于程序设计中经常使用循环结构，根据程序执行的局部性特点，可以设想在一段时间内经常被访问的代码和数据在将来也会经常被访问，显然这样的页面不应该被淘汰。
最近最不常用调度算法总是根据一段时间内页面的访问次数来选择淘汰页面，每次淘汰访问次数最少的页面。
算法实现时需要为每个页面设置计数器，记录访问次数。
计数器由硬件或操作系统自动定时清零。
（2）缺页调度次数和缺页中断率、缺页置换率计算缺页中断次数是缺页时发出缺页中断的次数。
缺页中断率=缺页中断次数/总的页面引用次数*100%缺页调度次数是调入新页时需要进行页面调度的次数缺页置换率=缺页调度次数/总的页面引用次数*100%二、总体设计1、算法的原理说明FIFO 先进先出调度算法：当页面框满时，最早进来的页面调出；LRU 最近最少使用调度算法：当页面框满时，最近最少使用的页面调出LFU 最近最不常用调度算法：当页面框满时，最近最不常用的页面调出SECOND 二次机会调度算法：当页面框满时，页面调入时R=0，当被访问时R = 1。
常用的页面调度算法
常用的页面调度算法一、引言在计算机科学中，页面调度算法是操作系统中的一种重要机制，用于管理计算机内存中的页面。
页面调度算法的目标是尽可能地提高内存的利用率，减少页面置换的次数，从而提高系统的性能和响应速度。
常用的页面调度算法有先进先出（FIFO）、最近最久未使用（LRU）和时钟（Clock）算法等。
本文将介绍这些常用的页面调度算法，并分析它们的优缺点及适用场景。
二、先进先出（FIFO）算法先进先出算法是最简单的页面调度算法之一。
它的原理是将最早进入内存的页面置换出去，即先进先出。
当内存空间不足时，操作系统将最早进入内存的页面替换出去，腾出空间给新的页面。
这种算法简单易实现，但是它没有考虑页面的使用频率和重要性，可能导致常用的页面被频繁替换，影响系统的性能。
三、最近最久未使用（LRU）算法最近最久未使用算法是一种常用的页面调度算法。
它的原理是根据页面的使用情况来进行页面置换。
当需要替换页面时，操作系统选择最近最久未使用的页面进行置换。
这种算法考虑了页面的使用频率，可以有效地提高内存的利用率。
然而，LRU算法的实现比较复杂，需要维护一个页面访问的时间戳列表，当页面被访问时，需要更新时间戳列表，这会带来额外的开销。
四、时钟（Clock）算法时钟算法是一种简化的页面调度算法，它是基于LRU算法的改进。
时钟算法使用一个循环链表来保存内存中的页面，并维护一个指针指向当前页面。
当需要替换页面时，时钟算法从当前页面开始顺时针扫描链表，找到一个未被访问的页面进行置换。
如果当前页面已被访问，则将访问位清零，并将指针指向下一个页面。
这种算法简化了LRU算法的实现，并且可以在O(1)的时间内完成页面置换操作。
五、比较和总结先进先出算法简单易实现，但没有考虑页面的使用频率和重要性；最近最久未使用算法考虑了页面的使用频率，可以提高内存的利用率，但实现较复杂；时钟算法是一种简化的LRU算法，可以在O(1)的时间内完成页面置换操作。
操作系统填空、名词解释、简答题题库完整
填空题1.操作系统的特征是（并发）,（共享）和（异步性）还有（虚拟）.2.按照用户界面的使用环境和功能特征的不同,一般可以把操作系统分为三种基本类型,即:（批处理系统）,（分时系统）和实时系统.3. 软件系统分为系统软件,（支撑软件）和（应用软件）.4.多数计算机系统将处理器的工作状态划分为（管态）和目态.后者一般指用户程序运行时的状态,又称为普通态或（用户态）.5. 存储器一般分成高速缓冲器,（内存）和（外存）三个层次,其中高速缓冲器是造价最高,存取速度最快.6.文件的物理结构有:顺序结构,（链接结构）和（索引结构）.8. 在单CPU系统中有n(n>1)个进程,在任一时刻处于就绪的进程最多是（n-1）个,最少是（0）个.9. 系统为每一台设备确定一个编号,以便区分和识别,这个确定的编号称为设备的（绝对）号.由用户在程序中定义的设备编号称为设备的（相对）号.10. 一个作业可划分成若干个（相对独立）的部分,每个部分称为一个（作业步）.11. 在批处理兼分时的系统中,往往由分时系统控制的作业称为（前台）作业,而由批处理系统控制的作业称为（后台）作业.12. 操作系统为用户提供两种类型的使用接口,它们是（操作员)接口和（程序员) 接口.13. 操作系统中,进程可以分为（系统）进程和（用户）进程两类.15. 除了新建状态与撤销状态，进程的基本状态有(运行)、（就绪）、（阻塞）。
16. 在响应比最高者优先的作业调度算法中,当各个作业等待时间相同时,（计算时间短）分母的作业将得到优先调度;当各个作业要求运行的时间相同时, （等待时间长）分子的作业得到优先调度.17. 当一个进程独占处理器顺序执行时,具有两个特性: （封闭）性和（可再现性）.18. Linux的shell有两层含义,一是指由（shell命令）组成的Shell 命令语言;二是指（该命令的解释）程序.19. 操作系统的主要设计目标是（方便用户使用）和（资源利用率高）.20. 当一个进程完成了特定的任务后,系统收回这个进程所占的（资源）和取消该进程的（进程控制块PCB），就撤消了该进程.21. 每个索引文件都必须有一张（索引）表,其中每个登记项用来指出一个逻辑记录的（存放位置或指针或首地址）.22. 实现SPOOL系统时必须在磁盘上辟出称为（输入#）和（输出#)的专门区域,以存放作业信息和作业执行结果.23. 一个理想的作业调度算法应该是既能（提高系统效率）又能使进入系统的作业（周转时间短）.24. 死锁的四个必要条件是（互斥使用资源）,（占用并等待资源）,不可抢夺资源和循环等待资源.25. 操作系统一般为用户提供了三种界面,它们是(命令界面),(图形界面)和系统调用界面.26. 进程间相互合作的关系是(同步)关系,而对资源争用的关系是(互斥)关系.若干进程使用同一临界资源时必须互斥执行.27. 处理机调度可分为三级,它们是作业调度,(进程调度)和CPU交换调度;在一般操作系统中,必须具备的调度是(进程调度).28. 一般说来,用户程序中所使用的地址是逻辑地址,而内存中各存储单元的地址是(物理地址或绝对地址);将前者转变为后者的过程称作(重定位).29. 在段页式存储管理系统中,面向(用户)的地址空间是段式划分,面向(物理实现)的地址空间是页式划分.30. 在Linux系统中,基本的文件类型分为(普通)文件,目录文件和文件, 所有的I/O设备按其物理特性分为(字符)设备和块设备.33. 操作系统的设备管理应具备的主要功能是(监视设备状态),(进行设备分配),完成I/O操作和缓冲管理与地址转换.34. 对信号量S每执行一次P操作,则信号量S的值就减1.当S的值小于0时,执行P操作的进程的状态就置为阻塞态,把相应的PCB连入该信号量队列的(末尾),并且该进程放弃处理机,由(进程调度程序)调度合适进程.35. 把逻辑地址转变为内存的物理地址的过程称作重定位,它分为(静态重定位)和(动态重定位)两种形式,在现代操作系统中都采用动态重定位形式来实现这种地址转换.37. SPOOLing的中文含义为（同时外围联机操作）或（假脱机操作）。
用先进先出（FIFO）页面调度算法处理缺页中断
//页面调度算法（FIFO）#include<stdio.h>#define TRUE 1#define FALSE 0#define MAX 7 // 页的最大数#define IN 4 // 在主存中的页数#define count 13 // 指令数量int P[IN]; // 表示已在主存中的页面int k; // 表示P数组中最先进入内存的页的位置typedef struct{int num; // 页号bool pre; // 标志int random; // 主存块号bool revise; // 修改标志int location; // 在磁盘上的位置}Page_Item;Page_Item Page_Record[MAX];// 指令数据结构typedef struct{char oper; // 操作符int Page_Num; // 页号int Unit_Num; // 单元号}Instruction;Instruction IC[count];// 初始化指令和页表void Init(){k=0; // 指向最先进入内存的页// 初始化页表Page_Record[0].num=0;Page_Record[0].pre=TRUE;Page_Record[0].random=5;Page_Record[0].revise=FALSE;Page_Record[0].location=011;Page_Record[1].num=1;Page_Record[1].pre=TRUE;Page_Record[1].random=8;Page_Record[1].revise=FALSE;Page_Record[1].location=012; Page_Record[2].num=2;Page_Record[2].pre=TRUE; Page_Record[2].random=9; Page_Record[2].revise=FALSE; Page_Record[2].location=013;Page_Record[3].num=3;Page_Record[3].pre=TRUE; Page_Record[3].random=1; Page_Record[3].revise=FALSE; Page_Record[3].location=021;Page_Record[4].num=4;Page_Record[4].pre=FALSE; Page_Record[4].random=0; Page_Record[4].revise=FALSE; Page_Record[4].location=022;Page_Record[5].num=5;Page_Record[5].pre=FALSE; Page_Record[5].random=0; Page_Record[5].revise=FALSE; Page_Record[5].location=023;Page_Record[6].num=6;Page_Record[6].pre=FALSE; Page_Record[6].random=0; Page_Record[6].revise=FALSE; Page_Record[6].location=121;// 初始化指令序列IC[0].oper='+';IC[0].Page_Num=0;IC[0].Unit_Num=70;IC[1].oper='+';IC[1].Page_Num=1;IC[1].Unit_Num=50;IC[2].oper='*';IC[2].Page_Num=2;IC[2].Unit_Num=15;IC[3].oper='w';IC[3].Page_Num=3;IC[3].Unit_Num=21;IC[4].oper='r';IC[4].Page_Num=0;IC[4].Unit_Num=56;IC[5].oper='-';IC[5].Page_Num=6;IC[5].Unit_Num=40;IC[6].oper='>';IC[6].Page_Num=4;IC[6].Unit_Num=53;IC[7].oper='+';IC[7].Page_Num=5;IC[7].Unit_Num=23;IC[8].oper='w';IC[8].Page_Num=1;IC[8].Unit_Num=37;IC[9].oper='r';IC[9].Page_Num=2;IC[9].Unit_Num=78;IC[10].oper='+';IC[10].Page_Num=4;IC[10].Unit_Num=1;IC[11].oper='r';IC[11].Page_Num=6;IC[11].Unit_Num=84;IC[12].oper='#';IC[12].Page_Num=0;IC[12].Unit_Num=0;}// 根据FIFO算法替换页,所需要的参数是被调入页的页结构体void replace(Page_Item page){// 被替换的页已经修改了if(TRUE==Page_Record[P[k]].revise){// 修改被调出页的存在标志Page_Record[P[k]].pre=FALSE;// 修改被调出页的修改标志Page_Record[P[k]].revise=FALSE;printf("调出%d页\n",P[k]);}// 将调入页的存在标志修改为TRUEpage.pre=TRUE;// 将被调出页的主存块号赋给调入页的主存块号page.random=Page_Record[P[k]].random;// 将调入页的页号赋给P[k]P[k]=page.num;printf("调入%d页\n",page.num);// 修改k指针k=(k+1)%IN;}// 指令执行过程void excute(){int i=0; // 指向当前正在执行的指令while('#'!=IC[i].oper){printf("执行%c指令,需%d页\n",IC[i].oper,IC[i].Page_Num);// 若正在执行的指令所需的页不在内存中if(FALSE==Page_Record[IC[i].Page_Num].pre){printf("该页不在内存中,请求调入.........\n");// 调用替换函数，调入所需的页replace(Page_Record[IC[i].Page_Num]);}// 修改指令对该页的操作if('+'==IC[i].oper||'*'==IC[i].oper||'-'==IC[i].oper||'>'==IC[i].oper){printf("%c指令修改了%d页\n",IC[i].oper,IC[i].Page_Num);// 修改该页的修改标志Page_Record[IC[i].Page_Num].revise=TRUE;}i++; // 指向下一条指令}for(i=0;i<IN;i++){if(TRUE==Page_Record[P[i]].revise){printf("%d页写回外存!\n",P[i]);}}}void main(){Init();excute();}。
LRU页面调度算法实现
LRU页面调度算法实现学院计算机科学与技术专业计算机科学与技术学号学生姓名指导教师姓名2014年3月16 日目录1.实验要求 (2)2.实验目的 (2)3.实验内容 (2)4.相关知识 (2)5.实验原理 (3)6.流程图 (4)7.源代码 (5)8.运行结果 (9)9.实验心得 (10)10.参考文献 (11)LRU页调度算法实现一实验要求：1．不同的功能使用不同的函数实现（模块化），对每个函数的功能和调用接口要注释清楚。
对程序其它部分也进行必要的注释。
2．对系统进行功能模块分析、画出总流程图和各模块流程图。
3．用户界面要求使用方便、简洁明了、美观大方、格式统一。
所有功能可以反复使用，最好使用菜单。
4．通过命令行相应选项能直接进入某个相应菜单选项的功能模块。
5．所有程序需调试通过。
二实验目的：将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。
进一步巩固和复习操作系统的基础知识。
培养学生结构化程序、模块化程序设计的方法和能力。
提高学生调试程序的技巧和软件设计的能力。
提高学生分析问题、解决问题以及综合利用C 语言进行程序设计的能力。
三实验内容：程序应模拟实现LRU 算法思想，对n个页面实现模拟调度。
四相关知识：1．虚拟存储器的引入：局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。
2．虚拟存储器的定义：虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。
3．虚拟存储器的实现方式：分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。
五．实验原理：目前有许多页面调度算法，本实验主要涉及最近最久未使用调度算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define null 0#define len sizeof(struct page)struct page{int num;int tag;struct page *next;};struct page *creat(int n){int count=1;struct page *p1,*p2,*head;head=p2=p1=(struct page *)malloc(len);p1->tag=-1;p1->num=-1;while(count<n){count++;p1=(struct page *)malloc(len);p1->tag=-1;p1->num=-1;p2->next=p1;p2=p1;}p2->next=null;return(head);}void FIFO(int array[],int n){int *p;int count=0;struct page *cp,*dp,*head,*newp;head=creat(n);p=array;while(*p!=-1){cp=dp=head;for(;cp->num!=*p&&cp->next!=NULL;)cp=cp->next;if(cp->num==*p) printf(" ! ");else{count++;cp=head;for(;cp->tag!=-1&&cp->next!=NULL;)cp=cp->next;if(cp->tag==-1){cp->num=*p;cp->tag=0;printf(" * ");}else{newp=(struct page*)malloc(len);newp->num=*p;newp->tag=0;newp->next=null;cp->next=newp;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu:%d\n",count);}void LRU(int array[],int n){int count=0,*p=array;struct page *head,*cp,*dp,*rp,*newp,*endp;head=creat(n);while(*p!=-1){cp=dp=rp=endp=head;//for(;endp->next!=NULL;) endp=endp->next;//for(;cp->num!=*p&&cp->next!=NULL;){rp=cp;cp->next;}if(cp->num==*p){printf(" ! ");if(cp->next!=null){if(cp!=head)rp->next=cp->next;else head=head->next;}endp->next=cp;cp->next=null;}else{count++;cp=rp=head;//for(;cp->tag!=-1&&cp->next!=null;)cp=cp->next;if(cp->tag==-1){printf(" * ");cp->num=*p;cp->tag=0;}else{newp=(struct page *)malloc(len);newp->num=*p;newp->tag=0;newp->next=null;cp->next=newp;dp=head;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye zongshu : %d \n",count);}void OPT(int array[],int n){int *p,*q,count=0,i;struct page *head,*cp,*dp,*newp;p=array;head=creat(n);while(*p!=-1){cp=head;//for(;cp->num!=*p&&cp->next!=null;)cp=cp->next;if(cp->num!=*p){count++;cp=head;//for(;cp->tag!=-1&&cp->next!=null;)cp=cp->next;if(cp->tag==-1){printf("*");cp->num=*p;cp->tag=0;}else{i=1;q=p;q++;cp=head;while(*q!=-1&&i<n){//for(;*q!=cp->num&&cp->next!=null;)cp=cp->next;if(*q==cp->num){cp->tag=1;i++;}q++;cp=head;}if(i==n){//for(;cp->tag!=0;)cp=cp->next;printf("%d",cp->num);cp->num=*p;}else{cp=head;//for(;cp->tag!=0;) cp=cp->next;if(cp==head){newp=(struct page *)malloc(len);newp->num=*p;newp->tag=0;newp->next=null;cp->next=newp;dp=head;head=head->next;printf("%d",dp->num);free(dp);}else{printf("%d",dp->num);cp->num=*p;}}cp=head;//for(;cp->next!=null;){cp->tag=0;cp=cp->next;}cp->tag=0;}}else printf("!");p++;}printf("\nQueye Zongshu:%d\n",count);}void main(){FILE *fp;char pt;char str[10];int i,j=0;int page[50],space=0;for(i=0;i<50;i++)page[i]=-1;fp=fopen("page.txt","r+");if(fp==NULL){printf("Can not open the file\n");exit(0);}i=0;while((pt=fgetc(fp))!=EOF){if(pt>='0'&&pt<='9'){str[i]=pt;i++;space=0;}else{if(pt==' '||pt=='\n'){if(space==1) break;else{str[i]='\0';page[j]=atoi(str);if(pt=='\n') break;else{space=1;j++;i=0;}}}}}if(pt==EOF){str[i]='\0';page[j]=atoi(str);}i=0;while(page[i]!=-1){printf(" %d ",page[i],i++);}fclose(fp);printf("\n !: mean no moved \n *: mean have free space \n\n");printf("FIFO ");FIFO(page,3);printf("\nLRU ");LRU(page,3);printf("\nOPT ");OPT(page,3);}。