常见缓存算法和LRU_C++实现

0.题目：设计一个数据结构实现LRU缓存

设计一个数据结构，实现LRU Cache(Least recently used) 功能。

支持get和set操作：

int get(int key);//如果key存在则返回key对应的value值，如果key不存在，则返回-1，（假设所有value>=0)

void set(int key,int value);//如果key不存在，则插入(key,value)结点，如果key存在，则使用新的value值代替老是value值

如果Cache的容量达到了限制，则需要在插入新元素前将最近最少使用的元素删除后，再进行插入。

使用的定义1：插入新节点或获取key值被视为一次使用，

而更新已经存在的节点的值，不算被使用。

使用的定义2：只有是使用了set和get都算被使用。

要求2：

要求在O(1）时间内实现get 和set操作！那就得使用hashmap来存这些（key,value)对了！这样查找的时间复杂度才能是O(1)

如果是使用map来存在这些(key,value）的话，查找的时间复杂度是O(logn)

 

下面先考虑最简单的情况：就是set和get都算使用，咱不考虑set和get的时间复杂的情况：

 

1.常见的缓存算法

• LRU (Least recently used) 最近最少使用，如果数据最近被访问过，那么将来被访问的几率也更高。
• LFU (Least frequently used) 最不经常使用，如果一个数据在最近一段时间内使用次数很少，那么在将来一段时间内被使用的可能性也很小。
• FIFO (Fist in first out) 先进先出， 如果一个数据最先进入缓存中，则应该最早淘汰掉。

2.LRU缓存

像浏览器的缓存策略、memcached的缓存策略都是使用LRU这个算法，LRU算法会将近期最不会访问的数据淘汰掉。LRU如此流行的原因是实现比较简单，而且对于实际问题也很实用，良好的运行时性能，命中率较高。下面谈谈如何实现LRU缓存：

• 新数据插入到链表头部
• 每当缓存命中（即缓存数据被访问），则将数据移到链表头部
• 当链表满的时候，将链表尾部的数据丢弃

 

LRU Cache具备的操作：

• set(key,value)：如果key在hashmap中存在，则先重置对应的value值，然后获取对应的节点cur，将cur节点从链表删除，并移动到链表的头部；若果key在hashmap不存在，则新建一个节点，并将节点放到链表的头部。当Cache存满的时候，将链表最后一个节点删除即可。
• get(key)：如果key在hashmap中存在，则把对应的节点放到链表头部，并返回对应的value值；如果不存在，则返回-1。

2.1LRU的c++实现

LRU实现采用双向链表 + Map 来进行实现。这里采用双向链表的原因是：如果采用普通的单链表，则删除节点的时候需要从表头开始遍历查找，效率为O(n)，采用双向链表可以直接改变节点的前驱的指针指向进行删除达到O(1)的效率。使用Map来保存节点的key、value值便于能在O(logN)的时间查找元素,对应get操作。

 双链表节点的定义：

struct CacheNode {
	int key;      // 键
	int value;    // 值
	CacheNode *pre, *next;  // 节点的前驱、后继指针
	CacheNode(int k, int v) : key(k), value(v), pre(NULL), next(NULL) {}
};

下面是LRUCache类的实现，操作函数都以内联的方式写出：

class LRUCache
{
private:
	int size;
	CacheNode* head;
	CacheNode* tail;
	map<int,CacheNode*> mp;

public:
	LRUCache(int capacity)
	{
		size = capacity;      // 容量
		head = NULL;          // 链表头指针
		tail = NULL;          // 链表尾指针
	}
	~LRUCache()
	{
		while (head)
		{
			delete head;
			head = head->next;
		}
	}
	//双链表的节点删除操作：
	void remove(CacheNode *node)
	{
		if (node->pre != NULL)
		{
			node->pre->next = node->next;
		}
		else
		{
			head = node->next;
		}
		if (node->next != NULL)
		{
			node->next->pre = node->pre;
		}
		else
		{
			tail = node->pre;
		}
	}

	//将节点插入到头部的操作：
	void setHead(CacheNode *node)
	{
		node->next = head;
		node->pre = NULL;

		if (head != NULL)
		{
			head->pre = node;
		}
		head = node;
		if (tail == NULL)
		{
			tail = head;
		}
	}

	//get(key)操作的实现比较简单，直接通过判断Map是否含有key值即可，如果查找到key，则返回对应的value，否则返回-1;
	int get(int key)
	{
		map<int, CacheNode *>::iterator it = mp.find(key);
		if (it != mp.end())
		{
			CacheNode *node = it->second;
			remove(node);
			setHead(node);
			return node->value;
		}
		else
		{//没有找到key值，就返回-1
			return -1;
		}
	}
	/*
	set(key, value)操作需要分情况判断。如果当前的key值对应的节点已经存在，则将这个节点取出来，
	并且删除节点所处的原有的位置，并在链表头部插入该节点；如果节点不存在节点中，
	这个时候需要在链表的头部插入新节点，插入新节点可能导致容量溢出，如果出现溢出的情况，
	溢出就是当前链表中结点的数目>=LRU的size;再插入新结点的化就溢出，
	则需要删除链表尾部的节点。

	*/

	void set(int key, int value)
	{
		map<int, CacheNode *>::iterator it = mp.find(key);
		if (it != mp.end())
		{
			CacheNode *node = it->second;
			node->value = value;
			remove(node);
			setHead(node);
		}
		else
		{
			CacheNode *newNode = new CacheNode(key, value);
			if (mp.size() >= size)
			{
				map<int, CacheNode *>::iterator iter = mp.find(tail->key);
				remove(tail);
				mp.erase(iter);
			}
			setHead(newNode);
			mp[key] = newNode;//mp[key]操作就是会用新的value覆盖老的value值！
		}
	}

};

测试代码：

int _tmain(int argc, _TCHAR* argv[])
{
	LRUCache *lruCache = new LRUCache(2);//容量是2的LRU缓存
	lruCache->set(2, 1);
	lruCache->set(1, 1);
	cout << lruCache->get(2) << endl;
	lruCache->set(4, 1);
	cout << lruCache->get(1) << endl;//返回-1，表面没有找到key=1的元素！
	cout << lruCache->get(2) << endl;
	cout << lruCache->get(4) << endl;

	system("pause");
	return 0;
}

/*
1
-1
1
请按任意键继续. . .
*/

常见缓存算法和LRU_C++实现 双向链表 key-value map hash_map

参考资料：

https://www.cnblogs.com/cpselvis/p/6272096.html