一、什么是LRU缓存算法
LRU,Least Recently Used算法,即一种缓存淘汰策略。
计算机的缓存容量有限,若缓存满了则需要删除一些内容,给新的缓存腾出空间,但问题是要删除哪些内容呢?当然是把用的少的缓存删掉,把最有用的数据继续保留以便于继续使用。那么如何判定哪些数据是有用的呢?
缓存淘汰的策略有很多,而LRU则是一种较为简单常用的算法,LRU判定最近使用过的数据为有用的,很久都没用过的数据是无用的,在内存满了就优先删除很久未使用,也就是无用的数据。
二、如何实现LRU缓存算法
LRU 缓存机制可以通过哈希表辅以双向链表实现,我们用一个哈希表和一个双向链表维护所有在缓存中的键值对。
双向链表按照被使用的顺序存储了这些键值对,靠近头部的键值对是最近使用的,而靠近尾部的键值对是最久未使用的。
哈希表即为普通的哈希映射(HashMap),通过缓存数据的键映射到其在双向链表中的位置。
这样以来,我们首先使用哈希表进行定位,找出缓存项在双向链表中的位置,随后将其移动到双向链表的头部,即可在 O(1)O(1) 的时间内完成 get 或者 put 操作。具体的方法如下:
对于 get 操作,首先判断 key 是否存在:
如果 key 不存在,则返回 -1−1;
如果 key 存在,则 key 对应的节点是最近被使用的节点。通过哈希表定位到该节点在双向链表中的位置,并将其移动到双向链表的头部,最后返回该节点的值。
对于 put 操作,首先判断 key 是否存在:
如果 key 不存在,使用 key 和 value 创建一个新的节点,在双向链表的头部添加该节点,并将 key 和该节点添加进哈希表中。然后判断双向链表的节点数是否超出容量,如果超出容量,则删除双向链表的尾部节点,并删除哈希表中对应的项;
如果 key 存在,则与 get 操作类似,先通过哈希表定位,再将对应的节点的值更新为 value,并将该节点移到双向链表的头部。
上述各项操作中,访问哈希表的时间复杂度为 O(1)O(1),在双向链表的头部添加节点、在双向链表的尾部删除节点的复杂度也为 O(1)O(1)。而将一个节点移到双向链表的头部,可以分成「删除该节点」和「在双向链表的头部添加节点」两步操作,都可以在 O(1)O(1) 时间内完成。
实现 LRUCache 类:
LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中,则返回关键字的值,否则返回 -1 。
void put(int key, int value) 如果关键字 key 已经存在,则变更其数据值 value ;如果不存在,则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ,则应该 逐出 最久未使用的关键字。
函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。
//创建一个结点类,用于实现双向链表
class Node {
public:
int key;
int val;
Node* prev, *next;
Node(): key(0), val(0), prev(nullptr), next(nullptr) {}
Node(int _key, int _value): key(_key), val(_value), prev(nullptr), next(nullptr) {}
};
class LRUCache {
public:
//通过哈希表进行访问查找
unordered_map<int, Node*> hash;
Node *head;
Node *tail;
int size;
int capacity;
//初始化
LRUCache(int capacity) {
head = new Node();
tail = new Node();
head -> next = tail;
tail -> prev = head;
this -> capacity = capacity;
this -> size = 0;
}
int get(int key) {
//如果关键字key存在于缓存中,返回关键字的值
//并且将访问的结点移到开头
if(hash.count(key)) {
Node *temp = hash[key];
movetoHead(temp);
return temp -> val;
}
//否则返回-1
return -1;
}
void put(int key, int value) {
//如果关键字key存在于缓存中,更新关键字的值,并移动到开头
if(hash.count(key)) {
Node *temp = hash[key];
temp -> val = value;
movetoHead(temp);
}
//如果不存在,则新建结点插入到开头
//如果关键字数量大于规定的capacity,则逐出末尾的节点
else {
++size;
Node *temp = new Node(key, value);
addtoHead(temp);
hash[key] = temp;
if(size > capacity) {
Node *del = removetail();
hash.erase(del -> key);
delete del;
--size;
}
}
}
//删除结点
void removeNode(Node *node) {
node -> prev -> next = node -> next;
node -> next -> prev = node -> prev;
}
//添加结点到链表头
void addtoHead(Node *node) {
node -> prev = head;
node -> next = head -> next;
head -> next -> prev = node;
head -> next = node;
}
//移除结点并将该结点移动到表头
void movetoHead(Node *node) {
removeNode(node);
addtoHead(node);
}
//删除末尾最久未使用的关键字
Node *removetail() {
Node *temp = tail -> prev;
removeNode(temp);
return temp;
}
};