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

LRU Cache 实现

    • 1. 什么是LRU cache
    • 2. Leetcode LRU cache
    • 3. C++ 实现

1. 什么是LRU cache

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

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

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

2. Leetcode LRU cache

  1. 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::liststd::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;
}

你可能感兴趣的:(算法与数据结构,算法,数据结构,c++)