页面置换算法（FIFO、LRU、LFU）c++实现

最新推荐文章于 2024-06-07 19:44:58 发布
最新推荐文章于 2024-06-07 19:44:58 发布
阅读量6.4k 收藏 34
点赞数 6
分类专栏： Windows开发、C++ 文章标签： 页面置换算法 LFU FIFO LRU
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_34785556/article/details/99192502
版权

1. FIFO(First in First out) -- 先进先出

先来先服务的策略。如果一个数据最先进入缓存中，则应该最早淘汰掉。也就是说，当缓存满的时候，应当把最先进入缓存的数据给淘汰掉。（这个可以类比队列较好理解）

实现：核心：双向链表实现队列+ hashmap

利用一个双向链表保存数据，当来了新的数据之后便添加到链表末尾，如果Cache存满数据，则把链表头部数据删除，然后把新的数据添加到链表末尾，这样插入和删除都可以在O（1）时间内完成。在访问数据的时候，如果在Cache中存在该数据的话，则返回对应的value值；否则返回-1。访问效率为O（n），可以通过添加hashmap来提高访问速度达到O（logn）。

#include"head.h"//头文件在最后处
#include<math.h>

class FIFOCache
{
public:

	FIFOCache(int capacity)
	{
		FIFOcapacity = capacity;
		FIFOsize = 0;
		list.Listcapcity = capacity;

	}

	int get(int key)
	{
		if (!FIFOmap.count(key))
			return -1;
		Node* node = FIFOmap[key];
		return node->val;
	}
	void put(int key, int value)
	{
		if (FIFOcapacity == 0)
			return;
		if (FIFOmap.count(key))
		{
			Node* node = FIFOmap[key];
			list.remove(node);
			node->val = value;
			list.append(node);
		}
		else
		{
			if (FIFOsize == FIFOcapacity)
			{
				Node* node = list.pop();
				int x = node->val;
				map<int, Node*>::iterator it3 = FIFOmap.find(x);
				//通过find拿到 node.val 为关键字的的迭代器
				FIFOmap.erase(it3);
				--FIFOsize;
			}
			Node* node = new Node(value);

			list.append(node);
			FIFOmap[key] = node;
			++FIFOsize;

		}
	}

	void printFIFO()
	{
		list.printList();
	}
	//数据成员
	int FIFOsize;
	int FIFOcapacity;
	DoubleList list;
	map<int, Node*>FIFOmap;
};

测试代码（FIFO）：

    FIFOCache cache(2);
	cache.put(1,1);
	cache.printFIFO();

	cache.put(2, 2);
	cache.printFIFO();

	cout << cache.get(1) << endl;

	cache.put(3, 3);
	cache.printFIFO();

	cout << cache.get(2) << endl;
	cache.printFIFO();

	cache.put(4, 4);
	cache.printFIFO();

	cout << cache.get(1) << endl;

2. LFU（Least Frequently Used） -- 最近最少使用

基于“如果一个数据在最近一段时间内使用次数很少，那么在将来一段时间内被使用的可能性也很小”的思路。

LFU是基于访问次数的。（这里可以把LFU看作是FIFO的优化，数据在原有基础增添一新的数据成员，用以计数数据被访问次数，按照数据被访问计数进行“分组”，计数相同的数据分为一组，淘汰时，选取最计数组，按照FIFO方法淘汰首元素）

实现：核心：存放双向链表的hashmap

LFU可以视为按频率“分组”的FIFO算法，所以我们利用hashmap，key存放数据被访问频率，key对应的value存放key频率下的双向链表。这样淘汰数据时，只要找到最小频率组，再按照FIFO策略淘汰数据即可。同时需要一个hashmap存放，数据地址，加快查找。

访问数据命中，则从相应的双向链表中删除，插入下一频数的双向链表，若该频数双向链表不存在则创建并插入；若删除数据使得双向链表为空，则删除双向链表。

#include"head.h"
#include<math.h>
class LFUNode :public Node//新定义的LFUNode类继承Node类基础上，添加freq数据成员作为计数
{
public:
	LFUNode() {}
	
	LFUNode(int x)
	{
		freq = 0;
		val = x;
	}
	int freq;
};

class LFUcache
{
public:
	LFUcache(int capacity)
	{
		LFUcapacity = capacity;
		LFUsize = 0;
		
	}

	void update(LFUNode*node) //更新节点 每次get或者put 访问频率改变
	{
		int freq = node->freq;
		//删除
		LFUNode* node1 = NULL;
		node1=(LFUNode*)freq_map[freq]->remove(node); ///
		if (freq_map[freq]->Listsize == 0)//如果该节点为最后一个节点，则删除双向链表
		{
			map<int, DoubleList*>::iterator it = freq_map.find(freq);
			freq_map.erase(it);
		}

		//更新
		++freq;
		node1->freq = freq;
		if (freq_map.count(freq))//该频率已存在，则尾部加入
		{
			freq_map[freq]->append(node1);//static_cast<Node*>(node)
		}
		else  //该频率未存在，则创建新双向链表插入
		{
			DoubleList* Dlist = new DoubleList();
			Dlist->append(node1);//
			freq_map[freq] = Dlist;
		}
	}
	int get(int key)
	{
		if (!LFUmap.count(key))
			return -1;
		else
		{
			LFUNode* node = LFUmap[key];
			update(node);
			return node->val;
		}
	}

	void put(int key,int value)
	{
		if (LFUcapacity == 0)
			return;
		if (LFUmap.count(key))//缓存命中
		{
			LFUNode* node = LFUmap[key];
			node->val = value;
			update(node);
		}
		else//缓存没有命中
		{
			if (LFUsize == LFUcapacity)
			{
				Node* node = NULL;
				map<int, DoubleList*>::iterator it1 = freq_map.begin();
				node =it1->second->pop();
				map<int, LFUNode*>::iterator it2 = LFUmap.find(node->val);
				LFUmap.erase(it2);
				--LFUsize;
			}
			LFUNode* lfNode = new LFUNode(value);
			lfNode->freq = 1;
			LFUmap[key] = lfNode;
			if (!freq_map.count(lfNode->freq))
			{
				freq_map[lfNode->freq] = new DoubleList();
			}
			freq_map[lfNode->freq]->append(static_cast<Node*>(lfNode));//
			++LFUsize;
		}
	}

	void printLFU()
	{
		cout << "---------Start-------------------"<< endl;
		for (map<int ,DoubleList*>::iterator it= freq_map.begin();  it != freq_map.end(); ++it)
		{
			cout << "Freq = " << it->first << " :" << endl;
			it->second->printList(); 
		}
		cout << "---------End-------------------"<< endl<<endl;
	}


	int LFUsize;
	int LFUcapacity;
	
	map<int, DoubleList*>freq_map;
	map<int, LFUNode*>LFUmap;

};

测试代码（LFU）：

LFUcache cache3(2);
	cache3.put(1, 1);
	cache3.printLFU();

	cache3.put(2, 2);
	cache3.printLFU();

	cout << cache3.get(1) << endl;
	cache3.printLFU();

	cache3.put(3, 3);
	cache3.printLFU();

	cout<<cache3.get(2) << endl;
	cache3.printLFU();
	cout << cache3.get(3) << endl;
	cache3.printLFU();

	cache3.put(4, 4);
	cache3.printLFU();

	cout << cache3.get(1) << endl;
	cache3.printLFU();
	cout << cache3.get(3) << endl;
	cache3.printLFU();
	cout << cache3.get(4) << endl;
	cache3.printLFU();

3. LRU（Least Frequently Used） -- 最近最久未使用

如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。（从描述来看和LFU很类似，区别在于，LRU注重的是访问时间，而LFU注重的是访问次数，考察细节不同，但大体方向类似）

实现：核心：双向链表实现队列+ hashmap

用一个双向链表来存储数据，并把相应的地址放入hashmap中，hashmap的作用主要是提高查找效率。当需要插入新的数据项的时候，如果新数据项在链表中存在（一般称为命中），则把该节点移到链表头部；如果不存在，则新建一个节点，放到链表头部。若缓存满了，则把链表最后一个节点删除即可。在访问数据的时候，如果数据项在链表中存在，则把该节点移到链表头部，否则返回-1。

#include"head.h"
#include<math.h>
class LRUcache
{
public:
	LRUcache(int capacity)
	{
		LRUcapacity = capacity;
		list.Listcapcity = capacity;
		LRUsize = 0;
	}
	int get(int key)
	{
		if (LRUmap.count(key))
		{
			Node* node = LRUmap[key];
			list.remove(node);
			list.append_front(node);
			return node->val;
		}
		else
			return - 1;
	}

	void put(int key, int value)
	{
		if (LRUcapacity == 0)
			return;
		if (LRUmap.count(key))
		{
			Node* node = NULL;
			node = list.remove(LRUmap[key]);
			node->val = value;
			list.append_front(node);
		}
		else
		{
			if (LRUsize == LRUcapacity)
			{
				Node* node = NULL;
				node= list.remove();
				int x = node->val;
				map<int, Node*>::iterator it = LRUmap.find(x);
				LRUmap.erase(it);
				--LRUsize;
			}
			Node* node = new Node(value);
			list.append_front(node);
			LRUmap[key] = node;
			++LRUsize;
		}
	}

	void printLRU()
	{
		list.printList();
	}
	//数据成员
	int LRUsize;
	int LRUcapacity;
	DoubleList list;
	map<int, Node*>LRUmap;
};

测试代码（LRU）：

    LRUcache cache2(2);
	cache2.put(2, 2);
	cache2.printLRU();

	cache2.put(1, 1);
	cache2.printLRU();

	cache2.put(3, 3);
	cache2.printLRU();

	cout << cache2.get(1) << endl;
	cache2.printLRU();

	cout << cache2.get(2) << endl;
	cache2.printLRU();

	cout << cache2.get(3) << endl;
	cache2.printLRU();

头文件：

#pragma once
#include<iostream>
#include<map>
using namespace std;

class Node
{
public:
	Node() {}
	Node(int x)
	{
		val = x;
	}
	int val = 0;
	Node* prev = NULL;
	Node* next = NULL;
};

class DoubleList
{
public:

	DoubleList(int capacity = 100)
	{
		Listsize = 0;
		head = NULL;
		tail = NULL;
		Listcapcity = capacity;
	}
	//头插入
	bool add_head(Node* node)
	{
		if (head == NULL)
		{
			head = node;
			tail = node;
			head->prev = NULL;
			tail->next = NULL;
			++Listsize;
			return false;
		}
		else
		{
			node->next = head;
			head->prev = node;
			head = node;
			head->prev = NULL;

			++Listsize;
			return true;
		}

	}

	//尾插入
	bool add_tail(Node* node)
	{
		if (tail == NULL)
		{
			head = node;
			tail = node;
			head->prev = NULL;
			tail->next = NULL;
			++Listsize;
			return true;
		}
		else
		{
			node->prev = tail;
			tail->next = node;
			tail = node;
			tail->next = NULL;
			++Listsize;
			return true;
		}
	}

	//任意删除
	Node* removerad(Node* node)
	{
		//node为 NULL 默认删除尾部节点
		if (node == NULL)
			node = tail;
		if (node == tail)
		{
			remove_tail();
			return node;
		}

		else if (node == head)
		{
			remove_head();
			return node;
		}

		else
		{
			node->prev->next = node->next;
			node->next->prev = node->prev;
			--Listsize;
			return node;
		}

	}
	//尾部删除
	Node* remove_tail()
	{
		if (Listsize == 0)
			return NULL;

		else if (Listsize == 1)
		{
			Node* node = tail;
			head = NULL;
			tail = NULL;
			--Listsize;
			return node;
		}
		else
		{
			Node* node = tail;
			tail = tail->prev;
			tail->next = NULL;
			--Listsize;
			return node;
		}
	}
	//头部删除
	Node* remove_head()
	{
		if (Listsize == 0)
			return NULL;

		else if (Listsize == 1)
		{
			Node* node = head;
			head = NULL;
			tail = NULL;
			--Listsize;
			return node;
		}
		else
		{
			Node* node = head;
			head = head->next;
			head->prev = NULL;
			--Listsize;
			return node;
		}
	}

	//外部接口：弹出头部
	Node* pop()
	{
		return remove_head();
	}

	//外部接口： 添加节点  从尾部
	bool append(Node* node)
	{
		return add_tail(node);
	}

	//外部接口： 添加节点  从头部
	bool append_front(Node* node)
	{
		return add_head(node);
	}

	//外部接口： 删除节点
	Node* remove(Node* node = NULL)
	{
		return removerad(node);
	}
	//外部接口： 打印链表
	void printList()
	{
		if (Listsize == 0)
			cout << "No Node..." << endl;
		else {
			Node* cur = head;
			cout << "{ ";
			while (cur != NULL)
			{
				cout << " -> " << cur->val ;
				cur = cur->next;
			}
			cout <<" }"<< endl;
		}

	}
	//数据成员部分
	int Listsize;
	int Listcapcity;
	Node* head;
	Node* tail;
};

 

LionelMessi7
关注
  • 6
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
操作系统 课程设计 页面置换算法FIFO和 LRU
08-14
本课程设计项目专注于两种常见的页面置换算法：FIFO（先进先出）和LRU（最近最少使用）。这两种算法都是为了在主存空间不足时决定哪些页面应该被换出到磁盘，以便腾出空间加载新的页面。 **FIFO页面置换算法**： ...
Unity 2D 学习手札（十二）Sprite 的触点处理
业精于勤，荒于嬉
03-17 635
前言 一个简单的范例，如下图的朴克牌，点一下就会翻过来，再点一次就盖起来。 朴克牌游戏对象 首先新增一个 Sprite 对象，用于显示朴克牌的点数，命名为 oneCard。然后在其下新增一个 Sprite 子对象，用于显示背面图像，命名为 imgBack。 由于 oneCard 要判断是否被点击，所以得添加一个Box 碰撞器。添加方式如下： 最后为此对象挂上一个脚本 Card.cs。 完整的程...
页面置换算法——C/C++实现 [ OTP, FIFO, LRU, LFU + 开源代码 + 详细解析]
热门推荐
Wang_Dou_Dou_的博客
12-24 2万+
关键字：C/C++实现、页面置换算法、最佳置换算法（OPT）、先进先出算法（FIFO）、最近最久未使用算法（LRU）、最不经常使用算法（LFU）、操作系统
理解和实现 LRU 缓存置换算法
最新发布
qq_41591215的博客
06-07 714
LRU算法的核心思想是：在缓存空间不足时，淘汰最长时间未被访问的数据项。这种策略适用于多种场景，包括Web缓存、数据库查询缓存、操作系统的页面置换等。
页面置换算法（FIFO、LRU）用C++实现
weixin_44735393的博客
01-17 5915
一、实验目的 为了使大的作业(其地址空间超过主存可用空间)或多个作业的地址空间之和超过实际主存空间时，仍能运行，引入了虚拟存储器的概念。使运行作业的一部分地址空间在主存,另一部分地址空间在辅存，由操作系统实现多级存储器的自动管理，实现主存空间的自动覆盖。要求学生通过本实验，对请求分页管理有一个清楚的概念。 二、实验原理 (1)在分页虚拟存储系统中，当硬件发出缺页中断后转操作系统处理缺页中断。查主存...
C++程序模拟实现页面替换算法——FIFO算法/LRU算法，附带讲解OPT算法
weixin_62760649的博客
01-20 1387
C++程序模拟实现页面替换算法——FIFO算法、LRU算法，附带讲解OPT算法
页面置换算法之最佳置换算法的模拟（C++）
falldeep的算法世界
10-11 6777
实验要求1）设计模拟实现OPT、FIFO和LRU页面置换算法中的任意一种。OPT算法：需要发生页面置换时，算法总是选择在将来最不可能访问的页面进行置换。FIFO算法：算法总是选择在队列中等待时间最长的页面进行置换。LRU算法：如果某一个页面被访问了，它很可能还要被访问；相反，如果它长时间不被访问，那么，在最近未来是不大可能被访问的。2)完成算法代码。3)运行程序，算出结果。设计思路模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时使用OPT算法进行页面置换的情形。
模拟实现页面置换算法（OPT、FIFO、LRU）C++代码
一只快乐的小蒟蒻~
11-13 3093
一、C++代码实现 #include <iostream> #include <algorithm> #include <cstring> #include <queue> #include <unordered_set> #include <ctime> using namespace std; typedef pair<int, int> PII; const int N = 1010;//执行序列最大长度 const
页面置换算法 FIFO NUR LRU LFU (2).docx
06-27
本报告将详细阐述三种常见的页面置换算法：FIFO（先进先出）、LRU（最近最少使用）以及LFU（最不经常使用），并介绍它们的设计原理、实现细节以及测试过程。 **FIFO（先进先出）**算法是最简单的页面置换策略。当...
操作系统页面置换算法实现，fifo、lfu、lru、opt，界面由MFC实现
03-28
本项目实现了一个模拟器，用于演示和比较四种不同的页面置换算法：FIFO（先进先出）、LFU（最不常用）、LRU（最近最少使用）以及OPT（最佳页面置换）。界面使用Microsoft Foundation Class (MFC)库来创建，使得用户...
FIFO，LRU，LFU 的三种页面置换算法的C++实现
04-09
OS操作系统上机题 FIFO，LRU，LFU 的三种页面置换算法的C++实现 {3,2,1,3,2,5,2,3,6,2,1,4,2} 为本实验例子的页面走向 copy直接可运行 提供简单可视化菜单 三种页面置换算法可供选择 注释详细，初学者亦可看懂
操作系统—页面置换算法（C++实现）
05-13
页面置换算法: 资源包含三个算法：OPT---最佳置换算法、//FIFO---先进先出、//LRU---最近最久未使用 操作：用户输入物理块数、页面待要访问的个数、每个页面编号，计算出缺页数、置换数、缺页率 语言：C++ 运行环境：Visual Studio 2013/更高版本
用C++实现LRU页面置换算法
06-03
使用LRU算法实现页面置换算法。LRU算法基于一种假设，长期不使用的数据，在未来的使用性也不大。因此，当数据占用内存达到一定的阙值时，我们要移除最近最少使用的数据。LRU算法中，使用了一种有趣的数据结构，叫做哈希链表。 我们都知道，哈希表是由若干个Key-Value所组成，在逻辑上，这些Key-Value是无所谓排列顺序的。 在哈希链表中，这些Key-Value不再是彼此无关的存在，而是被一个链条串联起来，每一个key-Value都有它的前驱和后继Key-value，就像双向链表中的节点一样。这样一来，无序的哈希表拥有了固定的排列顺序。
基于C语言实现的两种常见页面置换算法（OPT，LRU）
04-02
针对一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程，并计算访问命中率。要求设计主界面以灵活选择某算法，且以下算法都要实现 (1)最佳淘汰算法（OPT） (2)最近最少访问页面算法（LRU） 2.要有体现算法比较的程序输出，比如：缺页率和页面置换次数等。 3.采用固定分配局部置换，且可以在程序中实现块数重新分配。 具有抖动判断和Belady异常判断机制 根据设计要求实现对页面置换算法的模拟以及 进程状态转换的模拟。 1.根据自己输入 物理块数量,访问页面总数,要访问的页面号,  2.然后选择所需的置换算法 OPT,LRU 二选一. 计算过程,并得出 缺页次数,缺页率,置换次数,命中率的结果; 3.进行虚拟存储算法设计分析。
虚拟内存页面置换算法（OPT、FIFO、LRU）模拟与实现
weixin_47700137的博客
07-08 1万+
前言 需要调入新页面时，选择内存中哪个物理页面被置换，称为置换策略。页面置换算法的目标：把未来不再使用的或短期内较少使用的页面调出，通常应在局部性原理指导下依据过去的统计数据进行预测，减少缺页次数。 一、常用的页面置换算法 1）最佳置换算法(OPT)：置换时淘汰“未来不再使用的”或“在离当前最远位置上出现的”页面。 2）先进先出置换算法(FIFO)：置换时淘汰最先进入内存的页面，即选择驻留在内存时间最长的页面被置换。 3）最近最久未用置换算法(LRU)：置换时淘汰最近一段时间最久没有使用的页面，即选择上次使
操作系统——页面置换算法c++的实现（fifo和lru）
chenmoupeng的博客
12-07 5195
1、首先建立本次实验的流程图： 1、 然后建立储存相应页面的物理块： struct Physicalblock{ int name; int nomber;//优先级1，2，3 }pb[10]; 其中name表示页面名，nomber在lru算法中起到标记时间的作用 2、 设置一个指针，在fifo算法中指向最老进程 Physicalblock *p=pb;//指向最老进程的指针 3、...
页面置换算法（FIFO , LRU, OPT）（C++实现模拟）
肥宅Sean
06-27 1万+
简述 先输入一个N表示的是，页表大小（最多能存的帧数）。 之后的序列是最大为9，最小为0的一个申请序列。 之后的输入一个数字T，表示输入的测试命令的数目。 之后的命令。 第一个数表示使用什么页面置换算法。 1 表示FIFO. 2 表示LRU 3 表示OPT 第二个是什么操作： get A，B表示运行完第A个序列之后，B在也页表中么？在就输出1，否则0。 pf A表示的是，运行...
操作系统页面置换算法在C++中的实现
shenhaizpg的博客
05-24 2601
操作系统存储管理在C++中的实现 存储管理代码简介 存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。 本代码的目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。 代码实现 头文件及宏定义 #include<iostream> #include<time.h> #include<string> #include<map> using namespace std; #de
页面置换算法（FIFO，LRU，OPT）c模拟
03-21 4528
/* * memory.c * * Created on: Jun 9, 2010 * Author: WangYun */ #include #define PAGE_NUM 20 #define BLOCK 3 void get_page(int page_seq[]) { int i=PAGE_NUM; printf("Please input %d numb
opt,fifo,lru页面置换算法c++实现
05-31
以下是基于 C++ 的 OPT, FIFO, LRU 页面置换算法的实现代码： ```c++ #include <iostream> #include <vector> #include <queue> #include <algorithm> #include <unordered_map> using namespace std; // OPT 页面置换算法 int OPT(vector<int> pages, int frameSize) { int pageFaults = 0; unordered_map<int, int> nextUse; vector<int> frames(frameSize, -1); for(int i = 0; i < pages.size(); i++) { int page = pages[i]; if(find(frames.begin(), frames.end(), page) != frames.end()) { continue; } if(frames[frames.size() - 1] == -1) { frames[pageFaults] = page; pageFaults++; } else { for(int j = 0; j < frames.size(); j++) { int frame = frames[j]; if(nextUse.find(frame) == nextUse.end()) { nextUse[frame] = i; } else { if(nextUse[frame] < nextUse[frames[j]]) { nextUse[frame] = i; } } } int maxNextUse = -1; int pageToReplace = -1; for(int j = 0; j < frames.size(); j++) { int frame = frames[j]; if(nextUse[frame] > maxNextUse) { maxNextUse = nextUse[frame]; pageToReplace = frame; } } replace(frames.begin(), frames.end(), pageToReplace, page); pageFaults++; } } return pageFaults; } // FIFO 页面置换算法 int FIFO(vector<int> pages, int frameSize) { int pageFaults = 0; queue<int> frames; for(int i = 0; i < pages.size(); i++) { int page = pages[i]; if(find(frames.front(), frames.back(), page) != frames.back()) { if(frames.size() == frameSize) { frames.pop(); } frames.push(page); pageFaults++; } } return pageFaults; } // LRU 页面置换算法 int LRU(vector<int> pages, int frameSize) { int pageFaults = 0; unordered_map<int, int> lastUse; vector<int> frames(frameSize, -1); for(int i = 0; i < pages.size(); i++) { int page = pages[i]; if(find(frames.begin(), frames.end(), page) != frames.end()) { lastUse[page] = i; continue; } if(frames[frames.size() - 1] == -1) { frames[pageFaults] = page; lastUse[page] = i; pageFaults++; } else { int minLastUse = INT_MAX; int pageToReplace = -1; for(int j = 0; j < frames.size(); j++) { int frame = frames[j]; if(lastUse[frame] < minLastUse) { minLastUse = lastUse[frame]; pageToReplace = frame; } } replace(frames.begin(), frames.end(), pageToReplace, page); lastUse[page] = i; pageFaults++; } } return pageFaults; } int main() { vector<int> pages = {1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5}; int frameSize = 3; cout << "OPT 页面置换算法: " << OPT(pages, frameSize) << endl; cout << "FIFO 页面置换算法: " << FIFO(pages, frameSize) << endl; cout << "LRU 页面置换算法: " << LRU(pages, frameSize) << endl; return 0; } ``` 在这个代码中，我们定义了三个函数 `OPT`, `FIFO`, 和 `LRU`，分别实现了 OPT, FIFO, 和 LRU 页面置换算法。每个函数都接受一个整数数组 `pages` 和一个整数 `frameSize`，其中 `pages` 表示页面序列，`frameSize` 表示内存中页面框的数量。每个函数都返回页面缺页次数。 在 `OPT` 函数中，我们使用了一个哈希表 `nextUse` 来记录每个页面下一次使用的位置。当需要替换页面时，我们选择下一次使用最远的页面进行替换。 在 `FIFO` 函数中，我们使用了一个队列来记录页面。当需要替换页面时，我们选择队列中最早进入的页面进行替换。 在 `LRU` 函数中，我们使用了一个哈希表 `lastUse` 来记录每个页面上一次使用的位置。当需要替换页面时，我们选择上一次使用时间最早的页面进行替换。 注意，以上实现代码仅供参考。实际使用中，还需要考虑到多种情况，比如页面访问的顺序、页面分布的情况等等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LionelMessi7

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值