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
参考资料: