LRU Cache

最新推荐文章于 2024-05-10 11:12:24 发布

GSX_M

最新推荐文章于 2024-05-10 11:12:24 发布

阅读量654

点赞数

分类专栏：高阶数据结构文章标签：缓存

本文链接：https://blog.csdn.net/m0_52169086/article/details/127164659

版权

高阶数据结构专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1.什么是LRU Cache

2.LRU Cache的实现

3.LRU Cache的OJ

1.什么是LRU Cache

①LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。
②什么是 Cache？狭义的Cache指的是位于CPU和主存间的快速RAM，通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。广义上的Cache指的是位于速度相差较大的两种硬件之间，用于协调两者数据传输速度差异的结构。
③除了CPU与主存之间有Cache，内存与硬盘之间也有Cache，乃至在硬盘与网络之间也有某种意义上的Cache── 称为Internet临时文件夹或网络内容缓存等。
④Cache的容量有限，因此当Cache的容量用完后，而又有新的内容需要添加进来时，就需要挑选并舍弃原有的部分内容，从而腾出空间来放新内容。LRU Cache 的替换原则就是将最近最少使用的内容替换掉。其实，LRU译成最久未使用会更形象，因为该算法每次替换掉的就是一段时间内最久没有使用过的内容。

2.LRU Cache的实现

要设计出一个LRU cache不难，要设计出一个高效LRU Cahe有难度任意操作都是0(1)
实现LRU Cache的方法和思路很多，但是要保持高效实现O(1)的put和get，那么使用双向链表和哈希表的搭配是最高效和经典的。
使用双向链表是因为双向链表可以实现任意位置O(1)的插入和删除，使用哈希表是因为哈希表的增删查改也是O(1)。

3.LRU Cache的OJ

①整体代码

class LRUCache {
public:
    LRUCache(int capacity) 
        :_capicity(capacity)
    {}
    
    int get(int key) 
    {
       auto ret = _hashMap.find(key);
       if(ret != _hashMap.end()) //LRU中存储了key
       {
          //更新key对应值的位置，因为访问了一次key
          LtIter it = ret->second; //first:key , second:LtIter

          //更新方法
          //1.erase + push_front  要更新迭代器，那么原迭代器失效
          //2.splice 函数，转移节点
          _LRUList.splice(_LRUList.begin(),_LRUList,it);

          return it->second;
       }
       else
       {
          return -1;
       }
    }
    
    void put(int key, int value) 
    {
        //1.更新  2.插入
       auto ret = _hashMap.find(key);
       if(ret == _hashMap.end()) //不存在即插入
       {
          //判断LRU空间是否已经满了，满了要移出数据
          if(_capicity == _hashMap.size())  //list::size() 可能是O(N),调用的时候遍历
          {
              pair<int,int> back = _LRUList.back();
              _hashMap.erase(back.first);
              _LRUList.pop_back();
          }

          //有位置可以插入
          _LRUList.push_front(make_pair(key,value));
          _hashMap[key] = _LRUList.begin();
       }
       else //找到了，存在，即更新
       {
           //更新value
           LtIter it = ret->second;
           it->second = value;

           //更新key的位置，因为访问了一次
           _LRUList.splice(_LRUList.begin(),_LRUList,it);

       }
    }

private:
   typedef list<pair<int,int>>::iterator LtIter;

   //建立数据和存储位置的映射关系，这样查找更新效率为O(1)
   unordered_map<int,LtIter> _hashMap; 

   //假设尾部数据就是最新最少用
   list<pair<int,int>> _LRUList; //value可以是任意类型数据，通过key能找到
   size_t _capicity;  //LRU的容量
};

②private成员的设置

list<pair<int,int>> _LRUList 存储put进来的 key，value结构；且定义尾部就是最新最少使用的数据
unordered_map<int,LtIter> _hashMap 建立 key和 list迭代器的映射，使得增删改查为O(1)

③get函数获取value

通过key在_hashMap中利用find函数查找，判断是否存储了该数据的映射
如果有即 ret != _hashMap.end() , 我们即可通过ret 找到 list的迭代器，进而找到 value ；这里的一次查找操作可视为一次数据访问，要更新这对 (key , value)在 _LRUList中的位置，放到队头；最后返回value即可。
如果没有即 ret == _hashMap.end()，直接返回-1

    int get(int key) 
    {
       auto ret = _hashMap.find(key);
       if(ret != _hashMap.end()) //LRU中存储了key
       {
          //更新key对应值的位置，因为访问了一次key
          LtIter it = ret->second; //first:key , second:LtIter

          //更新方法
          //1.erase + push_front  要更新迭代器，那么原迭代器失效
          //2.splice 函数，转移节点
          _LRUList.splice(_LRUList.begin(),_LRUList,it);

          return it->second;
       }
       else
       {
          return -1;
       }
    }

④put函数更新 / 插入数据

通过key在_hashMap中利用find函数查找，判断是否存储了该数据的映射
如果没有即 ret == _hashMap.end() , 我们需要插入这个(key , value)键值对；插入之间需要判断题目所给的capicity是否已经满了，在这里判断需要用 _hashMap.size() 而不是 _LRUList.size() , 因为list::size()成员函数被调用时可能需要遍历一次为O(N) ; 如果容量满了要删除 _LRUList 队尾的数据，删除 _hashMap中的映射关系，然后通过put传入的参数建立新的映射关系到_hashMap中，将新的(key，value)键值对插入到_LRUList的头部.
如果有即 ret != _hashMap.end() , 我们需要更新key，对应的value值；更新操作也视为一次数据访问，需要把该(key，value)键值对放到 _LRUList 的队头中

  void put(int key, int value) 
    {
        //1.更新  2.插入
       auto ret = _hashMap.find(key);
       if(ret == _hashMap.end()) //不存在即插入
       {
          //判断LRU空间是否已经满了，满了要移出数据
          if(_capicity == _hashMap.size())  //list::size() 可能是O(N),调用的时候遍历
          {
              pair<int,int> back = _LRUList.back();
              _hashMap.erase(back.first);
              _LRUList.pop_back();
          }

          //有位置可以插入
          _LRUList.push_front(make_pair(key,value));
          _hashMap[key] = _LRUList.begin();
       }
       else //找到了，存在，即更新
       {
           //更新value
           LtIter it = ret->second;
           it->second = value;

           //更新key的位置，因为访问了一次
           _LRUList.splice(_LRUList.begin(),_LRUList,it);

       }
    }

⑤更新 (key,value)键值对位置有两种方法

1.erase + push_front 要更新迭代器，那么原迭代器失效
2.使用splice 函数，转移节点 (推荐)

代码示例:

#include<iostream>
#include<list>

using namespace std;

int main()
{
	list<int> li;
	li.push_back(1);
	li.push_back(2);
	li.push_back(3);
	li.push_back(4);
	li.push_back(5);

	for (auto& e : li)
	{
		cout << e << " ";
	}
	cout << endl;

	auto it = --(--li.end()); 
	cout << *it << endl; //4
	li.splice(li.begin(), li, it); //转移节点

	for (auto& e : li)
	{
		cout << e << " ";
	}
	cout << endl;

	return 0;
}