LRU Cache 实现
-
- [1. 什么是LRU cache](#1. 什么是LRU cache)
- [2. Leetcode LRU cache](#2. Leetcode LRU cache)
- [3. C++ 实现](#3. C++ 实现)
1. 什么是LRU cache
LRU全称是Least Recently Used,即最近最久未使用,是一种简单的缓存策略。顾名思义,LRU 算法会选出最近最少使用的数据进行淘汰。
那么什么是缓存(Cache)呢?缓存是一种提高数据读取性能的技术,可以有效解决存储器性能和容量的矛盾,是一种空间换时间的设计思想,比如我们常见的内存是硬盘的缓存 - Cache 就是内存的缓存,浏览器本地存储是网络访问的缓存...
在操作系统的内存管理中,有一类很重要的算法就是内存页面置换算法(包括FIFO,LRU,LFU等几种常见页面置换算法)。事实上,Cache算法和内存页面置换算法的核心思想是一样的:都是在给定一个限定大小的空间的前提下,设计一个原则如何来更新和访问其中的元素。
2. Leetcode LRU cache
- LRU 缓存,请你设计并实现一个满足 LRU (最近最少使用) 缓存约束的数据结构。
实现 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) 的平均时间复杂度运行。
拿到这个问题,首先需要思考,需要使用什么样的数据结构来实现这个算法呢?
我们需要有一个容器来存储这个键值对(key-value)通过get-key可以拿到相应的value值,同样可以用put 将键值对放入容器内。自然而然我们能想到的是map数据结构,进一步,如果想get和put的时间复杂度为 O ( 1 ) O(1) O(1),可以使用hash map来实现key的索引。但是又因为整个空间是有限的,也就是说map的size是定值,那么我们还需要一个数据结构来维护key的优先级,即新加入的key-value以及最近被索引的key-value优先级最高,按照优先级的大小,当容器容量超限的时候,我们删除优先级最低的即可,进一步如果想get和put的时间复杂度为 O ( 1 ) O(1) O(1),可以使用双向链表来实现key的优先级排序。
之所以选择双向链表而不是单链表,是为了可以从中间任意结点修改链表结构,而不必从头结点开始遍历
3. C++ 实现
我们使用C++标准库中的std::list
和std::unordered_map
来实现上述数据结构hash_map和双向链表,当然也可以手动实现。
std::list
是一个双向链表,支持在任何位置快速插入或删除元素,但是由于它是双向链表,它不支持和vector
一样可以通过索引去get固定位置的元素,只能通过迭代器遍历实现。
push_front(const T& x)
: 在链表头部添加一个元素。push_back(const T& x)
: 在链表尾部添加一个元素。pop_front()
: 删除链表头部的一个元素。pop_back()
: 删除链表尾部的一个元素。begin() / end()
: 返回指向容器中第一个元素/最后一个元素所在位置的下一个位置的双向迭代器。rbegin() / rend()
: 返回指向最后一个元素/第一个元素所在位置前一个位置的反向双向迭代器。size()
: 返回当前容器实际包含的元素个数。max_size()
: 返回容器所能包含元素个数的最大值。empty()
: 判断容器中是否有元素,若无元素,则返回 true;反之,返回 false。
std::unordered_map
是一个基于哈希表的关联容器,它存储的是键值对,键是唯一的。哈希表通过hash函数将key映射到特定的存储桶内
begin() / end()
: 返回指向容器中第一个键值对/最后一个键值对之后位置的正向迭代器。size()
: 返回有效元素个数。max_size()
: 返回unordered_map
支持的最大元素个数。empty()
: 判断是否为空。operator[]
: 访问元素。at()
: 访问元素。insert()
: 插入元素。erase()
: 删除元素。swap()
: 交换内容。clear()
: 清空内容。find()
: 通过给定主键查找元素。
cpp
/*
Implement of LRU cache
*/
#include <iostream>
#include <unordered_map>
#include <list>
// LRU template class, recv two type params: key & value
template <typename Key, typename Value>
class LRUCache
{
private:
// cache capacity
size_t _capacity = 0;
// list _keys中key的指向位置
std::unordered_map<Key, std::pair<Value, typename std::list<Key>::iterator>> _cache;
std::list<Key> _keys;
public:
// construct function
LRUCache(size_t size) : _capacity(size){};
Value get(Key key)
{
auto it = _cache.find(key);
if (it == _cache.end())
{
return -1;
}; // 返回默认值
_keys.splice(_keys.begin(), _keys, it->second.second);
return it->second.first;
}
void put(Key key, Value value)
{
auto it = _cache.find(key);
if (it != _cache.end())
{
it->second.first = value;
_keys.splice(_keys.begin(), _keys, it->second.second);
return;
}
if (_keys.size() == _capacity)
{
Key oldKey = _keys.back();
_keys.pop_back();
_cache.erase(oldKey);
}
_keys.push_front(key);
_cache[key] = {value, _keys.begin()};
}
void print()
{
for (auto it = _keys.begin(); it != _keys.end(); ++it)
{
std::cout << "Key: " << *it << " Value: " << _cache[*it].first << std::endl;
}
}
};
int main()
{
LRUCache<int, int> cache(2);
cache.put(1, 1);
cache.put(2, 2);
cache.print(); // 输出:Key: 2 Value: 2 \n Key: 1 Value: 1
std::cout << "Get key 1: " << cache.get(1) << std::endl; // 输出:Get key 1: 1
cache.put(3, 3); // 删除键2
cache.print(); // 输出:Key: 3 Value: 3 \n Key: 1 Value: 1
return 0;
}