[算法与数据结构]：LRU Cache 的原理与C++实现

1. 什么是LRU cache

​ LRU全称是Least Recently Used，即最近最久未使用，是一种简单的缓存策略。顾名思义，LRU 算法会选出最近最少使用的数据进行淘汰。

​ 那么什么是缓存(Cache)呢？缓存是一种提高数据读取性能的技术，可以有效解决存储器性能和容量的矛盾，是一种空间换时间的设计思想，比如我们常见的内存是硬盘的缓存 - Cache 就是内存的缓存，浏览器本地存储是网络访问的缓存…

​ 在操作系统的内存管理中，有一类很重要的算法就是内存页面置换算法（包括FIFO，LRU,LFU等几种常见页面置换算法）。事实上，Cache算法和内存页面置换算法的核心思想是一样的：都是在给定一个限定大小的空间的前提下，设计一个原则如何来更新和访问其中的元素。

2. Leetcode LRU cache

146. 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)$，可以使用hash map来实现key的索引。但是又因为整个空间是有限的，也就是说map的size是定值，那么我们还需要一个数据结构来维护key的优先级，即新加入的key-value以及最近被索引的key-value优先级最高，按照优先级的大小，当容器容量超限的时候，我们删除优先级最低的即可，进一步如果想get和put的时间复杂度为$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(): 通过给定主键查找元素。

/*
Implement of LRU cache
*/

#include 
#include 
#include 

// 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;
}