LRU页面置换算法C++代码

LRU页面置换算法C++代码

常见的缓存算法:

  • LRU:(least recently used) 最近最少使用,思想是如果一个数据刚被访问过,那么将来被访问的几率也更高
  • LFU:(least frequently used) 最少经常使用,思想是如果一个数据很久不被访问,那么将来被访问的几率也不大
  • FIFO:(first in first out) 先进先出,思想是如果一个数据最先进入缓存,则应该最早淘汰掉

我们这里主要看一看LRU缓存的规则:

  • 新数据插入到链接头部
  • 每当数据被访问,则将数据移到链表头部
  • 当链表满的时候,则将链表尾部的数据删除,在将新数据插入链表头部

 

LRU:cache应该具备的两个操作:

  1. get(key):如果key在hashmap中存在,则直接查找其在list链表中的位置,然后将其移动到链表头部再更新其hashmap的映射
  2. set(key,value):如果key在hashmap中不存在,并且页面还满了,则删除尾部节点,再插入,如果存在于hashmap中,则将其从list链表中移动到链表头部,再更新其hashmap的映射

我们现在自己手动实现一下:

我们这里LRU使用的是list + map来实现,采用list的原因是可以快速移动数据,而map用来保存节点的key,value的值,便于能快速根据key值找点其在list中对应的位置,所以value值保存的是list的迭代器类型

list + map的代码如下:

//查找时间复杂度 是map 红黑树 logn
#include 
#include 
#include 
#include 
#include 
using namespace std;

struct MyLRUnode
{
	int key;//形成key_value结构,通过这个唯一的键 直接可以找到这个值
	int value;
	MyLRUnode(int a, int b):key(a), value(b){}
};

class LRUCache
{
public:
	LRUCache(int size)
	{
		Lru_capacity = size;
	}
	int get(int key) //访问键为key的页面 找到 则将其重新插入到链表头
	{
		if(mymap.find(key) != mymap.end())//如果找到了
		{
			mylist.splice(mylist.begin(), mylist, mymap[key]);//则将mylist链表上找到的的iterator位置的元素重新链接到mylist.begin()位置上
			mymap[key] = mylist.begin();//然后将map映射表中 键为key的页面映射位置重置一下
			return mymap[key]->value;//最后返回将key对应的value返回
		}
		else//没找到 则返回-1
		{
			return -1;
		}
	}

	void put(int key, int value)//访问key value页面是否存在,若存在则提前“并更新value值”,不存在则创建之后再提前
	{
		if(mymap.find(key) == mymap.end())//key值不在页中
		{
			if(mylist.size() == Lru_capacity)//不在页中并且页还满了
			{
				mymap.erase(mylist.back().key);//将list尾部节点对应的key和其页映射关系删除
				mylist.pop_back();//将list尾部节点删除
			}
			MyLRUnode pnewnode(key, value);//创建新页
			mylist.push_front(pnewnode);//插入页链表中
			mymap[key] = mylist.begin();//key对应页面关系存入map
		}
		else//key值在页中
		{
			mymap[key]->value = value;//更新key对应的value值
			mylist.splice(mylist.begin(), mylist, mymap[key]);//将mylist链表上找到的的iterator位置的元素重新链接到mylist.begin()位置上
			mymap[key] = mylist.begin();//然后将map映射表中 键为key的页面映射位置重置一下
		}
	}

	void show_list()
	{
		list::iterator it = mylist.begin();
		for(;it != mylist.end();)
		{
			cout << it->key << ":" << it->value <::iterator>::iterator it = mymap.begin();
		while(it != mymap.end())
		{
			cout << it->first << ":" << (it->second)->value << endl;
			it++;
		}
		cout << endl;
	}
private:
	int Lru_capacity;
	list mylist;
	map::iterator> mymap;//用来通过key键值 直接找到对应的双向链表节点
	//hash_map::iterator> myhash_map;
};

int main()
{
	LRUCache lru(3);
	lru.put(1,100);
	lru.show_list();
	lru.show_map();
	lru.put(2,200);
	lru.show_list();
	lru.show_map();
	lru.put(3,300);
	lru.show_list();
	lru.show_map();
	lru.get(2);
	lru.show_list();
	lru.show_map();
	lru.put(4,400);
	lru.show_list();
	lru.show_map();
	return 0;
}

 

如果现在我们需要对其进行改进,map查找的时间复杂度还是有点大,是O(logn),我们怎么对其进行修改,修改为时间复杂度为O(1)呢?

说到O(1),我们第一时间想到的是哈希,所以我们可以使用hash_map将map替换掉即可,底层的hash_map会根据传入的key值,通过hash函数建立哈希表,以达到查找时间为O(1)

 

list + hash_map的代码如下:

//查找时间复杂度 是hash_map 映射表 查找时间复杂度 O(1)
#include 
#include 
#include 
#include 
#include 
using namespace std;

struct MyLRUnode
{
	int key;//形成key_value结构,通过这个唯一的键 直接可以找到这个值
	int value;
	MyLRUnode(int a, int b):key(a), value(b){}
};

class LRUCache
{
public:
	LRUCache(int size)
	{
		Lru_capacity = size;
	}
	int get(int key) //访问键为key的页面 找到 则将其重新插入到链表头
	{
		if(myhash_map.find(key) != myhash_map.end())//如果找到了
		{
			mylist.splice(mylist.begin(), mylist, myhash_map[key]);//则将mylist链表上找到的的iterator位置的元素重新链接到mylist.begin()位置上
			myhash_map[key] = mylist.begin();//然后将map映射表中 键为key的页面映射位置重置一下
			return myhash_map[key]->value;//最后返回将key对应的value返回
		}
		else//没找到 则返回-1
		{
			return -1;
		}
	}

	void put(int key, int value)//访问key value页面是否存在,若存在则提前“并更新value值”,不存在则创建之后再提前
	{
		if(myhash_map.find(key) == myhash_map.end())//key值不在页中
		{
			if(mylist.size() == Lru_capacity)//不在页中并且页还满了
			{
				myhash_map.erase(mylist.back().key);//将list尾部节点对应的key和其页映射关系删除
				mylist.pop_back();//将list尾部节点删除
			}
			MyLRUnode pnewnode(key, value);//创建新页
			mylist.push_front(pnewnode);//插入页链表中
			myhash_map[key] = mylist.begin();//key对应页面关系存入map
		}
		else//key值在页中
		{
			myhash_map[key]->value = value;//更新key对应的value值
			mylist.splice(mylist.begin(), mylist, myhash_map[key]);//将mylist链表上找到的的iterator位置的元素重新链接到mylist.begin()位置上
			myhash_map[key] = mylist.begin();//然后将map映射表中 键为key的页面映射位置重置一下
		}
	}

	void show_list()
	{
		list::iterator it = mylist.begin();
		for(;it != mylist.end();)
		{
			cout << it->key << ":" << it->value <::iterator>::iterator it = myhash_map.begin();
		while(it != myhash_map.end())
		{
			cout << it->first << ":" << (it->second)->value << endl;
			it++;
		}
		cout << endl;
	}
private:
	int Lru_capacity;
	list mylist;
	//map::iterator> mymap;//用来通过key键值 直接找到对应的双向链表节点
	hash_map::iterator> myhash_map;
};

int main()
{
	LRUCache lru(3);
	lru.put(1,100);
	lru.show_list();
	lru.show_map();
	lru.put(2,200);
	lru.show_list();
	lru.show_map();
	lru.put(3,300);
	lru.show_list();
	lru.show_map();
	lru.get(2);
	lru.show_list();
	lru.show_map();
	lru.put(4,400);
	lru.show_list();
	lru.show_map();
	return 0;
}

 

你可能感兴趣的:(算法,数据结构,C++)