? LRU全称是Least Recently Used，即最近最久未使用，是一种简单的缓存策略。顾名思义，LRU 算法会选出最近最少使用的数据进行淘汰。
? 那么什么是缓存(Cache)呢？缓存是一种提高数据读取性能的技术，可以有效解决存储器性能和容量的矛盾，是一种空间换时间的设计思想，比如我们常见的内存是硬盘的缓存 - Cache 就是内存的缓存，浏览器本地存储是网络访问的缓存…
? 在操作系统的内存管理中，有一类很重要的算法就是内存页面置换算法（包括FIFO，LRU,LFU等几种常见页面置换算法）。事实上，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的优先级排序。
之所以选择双向链表而不是单链表，是为了可以从中间任意结点修改链表结构，而不必从头结点开始遍历
我们使用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(): 通过给定主键查找元素。/*
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;
}