运用你所掌握的数据结构，设计和实现一个LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。
获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。
进阶:
你是否可以在 O(1) 时间复杂度内完成这两种操作？
示例:
LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1);
// 返回 1
cache.put(3, 3); // 该操作会使得密钥 2 作废
cache.get(2);
// 返回 -1 (未找到)
cache.put(4, 4); // 该操作会使得密钥 1 作废
cache.get(1);
// 返回 -1 (未找到)
cache.get(3);
// 返回 3
cache.get(4);
// 返回 4
算法
这题的时间复杂度的好坏比较依赖于所选择的数据结构。
LRU是操作系统中提出的一种应用于页置换的算法，这里不过多介绍，举个实际例子即可知道本题要求实现的功能需要什么步骤：
想象有一个队列的最大允许空间为3，
依次入队的顺序为 2，3，2，1，2，4；求LRU算法下队列的演变过程。
---------------------------------------------------
- 队列初始为空，2进入后队列情况为：2
- 队列还有2个剩余位置，3进入后队列情况为：2 3
- 队列还有1个剩余位置，这次入队的数据为2，它本来就已在队列中，根据LRU算法，需要将2调到队列末尾，因此队列情况为：3 2
- 队列还有1个剩余位置，这次入队数据为1，入队后队列情况为：2 3 1
- 队列已经没有剩余位置，但是入队数据为2，它本来就在队列中，根据LRU算法，需要将2调到队列末尾，因此队列情况为：3 1 2
- 队列已经没有剩余位置，新进入的数据为4，根据LRU需要淘汰最近最少被使用的数据，即队首的数据3，更新后队列情况为：1 2 4
---------------------------------------------------
上面即为LRU算法的一个例子
选择hash表与双向链表作为实现主体功能的两个数据结构，主要是因为双向链表便于插入删除，而hash表可以较快查找到需要返回的value。具体一点，整个LRUCache可能长下面这样：
代码
#include <iostream>
#include <list>
#include <unordered_map>
using namespace std;
struct listNode{
int key, value;
listNode *pre, *next;
listNode(int _key, int _value): key(_key), value(_value)
{
pre = next = NULL;
}
};
class LRUCache {
public:
// hash_table末端保存最近刚被使用的节点，前端保存最近最少被使用节点
unordered_map<int, listNode*> hash_table;
listNode *head, *tail;
int cap, size;
LRUCache(int capacity) {
cap = capacity;
size = 0;
head = new listNode(-1, -1);
tail = new listNode(-1, -1);
head->next = tail;
tail->pre = head;
}
int get(int key) {
if (hash_table.find(key) == hash_table.end())
return -1;
else
{
// 记录该ID指向节点的指针
listNode *tmp = hash_table[key];
/*** 更改节点在表中的顺序 ***/
// 1. 删除hash_table[key]
delNode(tmp);
// 2. 将hash_table[key]插入末尾
pushNodeBack(tmp);
return tmp->value;
}
}
void put(int key, int value) {
// 这个key本身保存在表中
if (hash_table.find(key) != hash_table.end())
{
listNode *tmp = hash_table[key];
// 从链表头部去掉这个点
delNode(tmp);
// 更新表中key对应链表节点的value
tmp->value = value;
// 从链表尾部插入这个点
pushNodeBack(tmp);
return;
}
// 链表的空间已满
if (cap == size)
{
// 空间不够，踢出队列最前端的ID
listNode *tmp = head->next;
// 在表中删除这个点
hash_table.erase(tmp->key);
// 从链表头部去掉这个点
delNode(tmp);
// 释放被删除的点的空间
delete tmp;
}
else
size++;
listNode *node = new listNode(key, value);
hash_table[key] = node;
pushNodeBack(node);
}
void delNode(listNode *node)
{
node->pre->next = node->next;
node->next->pre = node->pre;
}
void pushNodeBack(listNode *node)
{
tail->pre->next = node;
node->pre = tail->pre;
node->next = tail;
tail->pre = node;
}
};
int main()
{
LRUCache *cache = new LRUCache(2);
cache->put(1, 1);
cache->put(2, 2);
cout << cache->get(1) << endl;
// 返回 1
cache->put(3, 3);
// 该操作会使得密钥 2 作废
cout << cache->get(2) << endl;
// 返回 -1 (未找到)
cache->put(4, 4);
// 该操作会使得密钥 1 作废
cout << cache->get(1) << endl;
// 返回 -1
cout << cache->get(3) << endl;
// 返回 3
cout << cache->get(4) << endl;
// 返回 4
}
