其它高阶数据结构④_LRU_Cache（概念+实现OJ）

最新推荐文章于 2024-07-02 10:52:42 发布
最新推荐文章于 2024-07-02 10:52:42 发布
阅读量988 收藏 18
点赞数 11
分类专栏： ⑩其它高阶数据结构（C++描述） ⑤高阶数据结构与算法（C++描述） 文章标签： 数据结构 c++ 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GRrtx/article/details/138232050
版权

目录

1. LRU_Cache的概念

2. LRU_Cache的实现

2.1 力扣146. LRU 缓存

2.2 LRU结构设计分析

2.3 get函数的实现

2.4 put函数的实现

2.5 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译成最久未使用会更形象， 因为该算法每次替换掉的就是一段时间内最久没有使用过的内容。

百度百科：

        LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 t，当须淘汰一个页面时，选择现有页面中其 t 值最大的，即最近最少使用的页面予以淘汰。

        最近最少使用算法（LRU）是大部分操作系统为最大化页面命中率而广泛采用的一种页面置换算法。该算法的思路是，发生缺页中断时，选择未使用时间最长的页面置换出去。 [1]从程序运行的原理来看，最近最少使用算法是比较接近理想的一种页面置换算法，这种算法既充分利用了内存中页面调用的历史信息，又正确反映了程序的局部问题。

2. LRU_Cache的实现

        实现LRU Cache的方法和思路很多,但是要保持高效实现O（1）的put和get，那么使用双向链表和哈希表的搭配是最高效和经典的

        使用双向链表是因为双向链表可以实现任意位置O（1）的插入和删除，使用哈希表是因为哈希表的增删查改也是O（1）。

下面通过一道题讲解LRU_Cache的实现。

2.1 力扣146. LRU 缓存

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) 的平均时间复杂度运行。

示例：

输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

提示：

  • 1 <= capacity <= 3000
  • 0 <= key <= 10000
  • 0 <= value <= 10^5
  • 最多调用 2 * 10^5 次 get 和 put
class LRUCache {
public:
    LRUCache(int capacity) {

    }
    
    int get(int key) {

    }
    
    void put(int key, int value) {

    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */

2.2 LRU结构设计分析

首先想到的实现结构是这样的（能做到O（1）吗）:

private:
	unordered_map<int, int> _hashMap; // hash能做到查找get更新是O(1)
	list<pair<int, int>> _LRUList; // 假设尾部数据就是最近少用的,最近使用的放在头部
	size_t _capacity; // 标记容量,满了就弹出链表尾的元素+在哈希表删除该元素的键值对

此时:

int get(int key) {}
void put(int key, int value) {}
  • get：直接查map,时间复杂度是O（1）。
  • put：如果是新增元素就是O（1），直接插入。但如果是修改更新：就是O（N），因为要在map查找完成后，在_LRUList中找到该元素key所在位置，只能遍历查找，时间复杂度是O（N），然后把该元素key放在头部：O（1）。

破局点：找到key之后，就要找到key对应存储的数据在链表中的位置。

        所以：_hashMap中可以存list的迭代器， 之前实现过list，所以知道list的迭代器本质是节点的指针。即：

private:
	unordered_map<int, list<pair<int, int>>::iterator> _hashMap; // hash能做到查找get更新是O(1)
	list<pair<int, int>> _LRUList; // 假设尾部数据就是最近少用的,最近使用的放在头部
	size_t _capacity; // 标记容量,满了就弹出链表尾的元素+在哈希表删除该元素的键值对

        这个结构相当于真正的数据在list里面，在map中查找key，就可以直接在链表中找到这个节点,，然后把这个节点转移到链表头部。

2.3 get函数的实现

  1. 在map中查找key是否存在，如果不存在，返回-1。
  2. 如果存在，把该key放到list的头部 -> 转移节点，然后返回key对应的值元素存在list里面， _hashMap中的key值：list的迭代器。

        如果key对应的值存在，则取出迭代器，这里就可以看出hashmap的value存的是list的iterator的好处：找到key 也就找到key存的值在list中的iterator，也就直接删除，再进行头插，实现O（1）的数据挪动。

        转移节点可以用到list的splice接口：splice函数用于两个list容器之间的拼接（数据转移)），其有三种拼接方式：

  1. 将整个容器拼接到另一个容器的指定迭代器位置。
  2. 将容器当中的某一个数据拼接到另一个容器的指定迭代器位置。
  3. 将容器指定迭代器区间的数据拼接到另一个容器的指定迭代器位置。

        容器当中被拼接到另一个容器的数据在原容器当中就不存在了。（实际上就是将链表当中的指定结点拼接到了另一个容器当中）。

get函数代码如下：

    int get(int key) 
    {
        //_hashMap中的key: key value：list的迭代器(LtIter)
        auto ret = _hashMap.find(key);//先查找是否在哈希表中
        if(ret != _hashMap.end()) // 存在
        {
            // 更新当前元素到链表头部
            LtIter it= ret->second; // 该元素在list中的位置
            // 把元素转移到链表头部,相当于头插,但是这这里不用更新迭代器,因为迭代器里面存的还是这个节点的指针
            _LRUList.splice(_LRUList.begin(), _LRUList, it);
            //it:是链表的迭代器,调用operator->,返回数据的地址,list中的数据是pair,所以返回的是pair*
            //pair<int,int>  我们要的是第二个成员的值,本来应该是it->->second 但是省略了一个箭头 
            return it->second; // 返回key对应的value 
        }
        else // 该元素不存在
        {
            return -1;
        }
    }

2.4 put函数的实现

  • 首先在map中查找key是否存在，如果不存在，那就要新增：
  1. 判断是否满了，如果满了，需要先删除list中尾部的数据，然后在哈希表中也要删除该元素。
  2. 然后把该 {key-value}头插到链表中 , 在哈希表中新增键值对{key-该位置在链表的迭代器}。

需要注意的是，判断容量的时候，最好不要使用求list的大小来判断， 因为C++中，这个方法可能不是O（1），直接用哈希表的大小就行了。

  • 如果已经存在了，那就修改数据，然后把该key放到list的头部。

put函数代码如下：

    void put(int key, int value)
    {
        auto ret = _hashMap.find(key);
        if(ret == _hashMap.end()) // 不存在->新增
        {
            //判断容量的时候,最好不要使用求list的大小来判断,因为C++中,这个方法可能不是O(1)
            //if(_capacity == _LRUList.size()) 不建议
            if(_capacity == _hashMap.size()) // 容量满了
            {
                pair<int, int> back = _LRUList.back(); // 取出链表尾部的数据
                //在哈希表中删除该数据 + 在链表弹出该元素
                _hashMap.erase(back.first);//back.first是key
                _LRUList.pop_back();
            }
            //头插入当前元素 + 哈希表新增键值对{key-该元素在list的位置(链表头部)}
            _LRUList.push_front(make_pair(key, value));
            _hashMap[key] = _LRUList.begin();
        }
        else
        {
            // 修改节点的值 + 当前数据放到链表头部
            auto it = ret->second; // it是list的迭代器
            it->second = value; // 更新节点的值
            _LRUList.splice(_LRUList.begin(),_LRUList,it); // 把当前节点转移到头部
        }
    }

2.5 OJ完整代码

class LRUCache {
private:
	unordered_map<int, list<pair<int, int>>::iterator> _hashMap; // hash能做到查找get更新是O(1)
	list<pair<int, int>> _LRUList; // 假设尾部数据就是最近少用的,最近使用的放在头部
	size_t _capacity; // 标记容量,满了就弹出链表尾的元素+在哈希表删除该元素的键值对

public:
    LRUCache(int capacity)
        : _capacity(capacity)
    {}
    
    int get(int key) 
    {
        //_hashMap中的key: key value：list的迭代器(LtIter)
        auto ret = _hashMap.find(key);//先查找是否在哈希表中
        if(ret != _hashMap.end()) // 存在
        {
            // 更新当前元素到链表头部
            auto it= ret->second; // 该元素在list中的位置
            // 把元素转移到链表头部,相当于头插,但是这这里不用更新迭代器,因为迭代器里面存的还是这个节点的指针
            _LRUList.splice(_LRUList.begin(), _LRUList, it);
            //it:是链表的迭代器,调用operator->,返回数据的地址,list中的数据是pair,所以返回的是pair*
            //pair<int,int>  我们要的是第二个成员的值,本来应该是it->->second 但是省略了一个箭头 
            return it->second; // 返回key对应的value 
        }
        else // 该元素不存在
        {
            return -1;
        }
    }

    void put(int key, int value)
    {
        auto ret = _hashMap.find(key);
        if(ret == _hashMap.end()) // 不存在->新增
        {
            //判断容量的时候,最好不要使用求list的大小来判断,因为C++中,这个方法可能不是O(1)
            //if(_capacity == _LRUList.size()) 不建议
            if(_capacity == _hashMap.size()) // 容量满了
            {
                pair<int, int> back = _LRUList.back(); // 取出链表尾部的数据
                //在哈希表中删除该数据 + 在链表弹出该元素
                _hashMap.erase(back.first);//back.first是key
                _LRUList.pop_back();
            }
            //头插入当前元素 + 哈希表新增键值对{key-该元素在list的位置(链表头部)}
            _LRUList.push_front(make_pair(key, value));
            _hashMap[key] = _LRUList.begin();
        }
        else
        {
            // 修改节点的值 + 当前数据放到链表头部
            auto it = ret->second; // it是list的迭代器
            it->second = value; // 更新节点的值
            _LRUList.splice(_LRUList.begin(),_LRUList,it); // 把当前节点转移到头部
        }
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */

本篇完。

下一篇是其它高阶数据结构⑤_B树（概念+实现OJ）

GR鲸鱼
关注
  • 11
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
lru-cache：C ++中功能完整的LRU缓存实现
02-05
在C++中实现LRU缓存，需要理解数据结构和算法的基础知识，特别是哈希表和双向链表的应用。 在C++中，LRU缓存通常通过结合哈希表（如`std::unordered_map`）和双向链表（如`std::list`或自定义实现）来实现。哈希表...
backports.functools_lru_cache
04-12
在发布的Python 3.3中的functools.lru_cache的反向。 用法 考虑使用此技术导入“ lru_cache”函数： try: from functools import lru_cache except ImportError: from backports.functools_lru_cache import lru_...
【深入理解LRU Cache】：缓存算法的经典之作
StuLearn-LJC的博客
03-07 3474
​LRU Cache（Least Recently Used的缩写，即最近最少使用，它是一种Cache的替换算法。看Cache替换算法这篇文章）是一种常见的缓存淘汰算法。用于在有限的缓存空间中管理数据对象。LRU Cache 的核心思想是基于时间局部性原理，即最近被访问的数据在未来可能会被再次访问。
【高阶数据结构】LRU Cache
chuxinchangcun的博客
09-07 6390
LRU Cache的介绍+OJ题目实现
高阶数据结构（3）并查集：并查集原理、并查集实现、并查集应用；LRUCache：概念、LRU Cache的实现、JDK中类似LRUCahe的数据结构LinkedHashMap、LRU Cache的OJ
m0_74343467的博客
12-05 115
高阶数据结构（3）并查集：并查集原理、并查集实现、并查集应用；LRUCache：概念、LRU Cache的实现、JDK中类似LRUCahe的数据结构LinkedHashMap、LRU Cache的OJ
【C++高阶数据结构】LRU
YQ20210216的博客
01-05 403
​ 🌈⭐️⚡若有帮助可以【关注】，大家一起进步！
【高阶数据结构】LRUCache
不能再留遗憾了的博客
03-02 885
什么是LRUCache，如何自己实现 LRUCache
高阶查找算法第一篇
开心的博客
10-25 837
二分法查找，顺序表查找优化，线性索引查找，哈希表设计，，斐波那契查找，二叉树搜索，位图，布隆过滤器，LRUCache
【檀越剑指大厂--redis】redis高阶篇
热门推荐
檀越的博客
09-08 1万+
Redis没有直接使用C语言传统的字符吕表示 (以空字符结尾的字符数组，以下简称C字符串)，而是自己构建了 一种名为简单动态字符串(simple dynamic string，SDS)的抽象象类型，并将SDS用作 Redis的默认字符串表示。存储String类型的key-value时,key和value都是SDS类型的.字符串键值都用SDS表示.//字节数组 char buf [ ];//buf数组中已使用字节数量 int len;//buf数组中未使用字节数量 int free;}
高阶数据结构（4）基本搜索结构 （内存中保存索引的缺陷、加速数据访问的策略、存储分类 ）、B/B-树（概念、性质、插入、验证、删除、性能分析）、B+树、B*树、B-树的应用——索引 ：MySQL索引
m0_74343467的博客
12-11 164
高阶数据结构（4）基本搜索结构 （内存中保存索引的缺陷、加速数据访问的策略、存储分类 ）、B/B-树（概念、性质、插入、验证、删除、性能分析）、B+树、B*树、B-树的应用——索引 ：MySQL索引
Elasticsearch基础整理 脑图
qqwwssaagg的博客
09-11 1013
Elasticsearch知识整理，基于ES6.7.1 主要涉及ES集群各模块功能及使用说明，集群选举流程 读取/写入流程等等，不涉及dsl等具体操作，后面会持续更新！ 需要完整文件 到我 公众号 ‘Lucene Elasticsearch 工作积累’ 回复 ‘es基础’ 就可以了！ 如果喜欢搜索技术请来我的公众号吧 ‘Lucene Elasticsearch 工作积累’ 每天会持续更新搜索相关技术 以下是脑图中的具体内存大纲。 集群节点角色 主节点 Master node ) 维护集群状态。集群状
LRU-update-Cache-.zip_LRU cache
09-19
LRU置换算法是选择最近最久未使用的页面予以置换。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来经历的时间T，当须淘汰一个页面时，选择现有页面中T值最大的，即最近最久没有访问的页面。这是...
backports.functools_lru_cache-1.5.tar
07-24
python源码安装包backports.functools_lru_cache-1.5.tar 解压后python setup.py install 进行安装
LRU.rar_LRU_lru 算法_lru算法
09-23
在编程语言中，LRU缓存的实现通常会用到数据结构如Java的`LinkedHashMap`，Python的`collections.OrderedDict`等，它们能方便地实现按访问顺序更新的数据结构。 LRU算法的优点在于其简单性和高效性，它能在大多数...
数据结构(3.3)——栈的链式存储结构
m0_65240792的博客
06-30 273
采用链式存储的栈成为链栈的优点是便于多个栈共享存储空间和提高其效率，且。通常采用单链表实现。
数据结构-线性表的应用
pyc68的博客
07-02 1180
本篇文章介绍线性表的应用，分别使用顺序表和单链表实现有序表的合并，最后介绍如何使用单链表实现两个稀疏多项式的相加和相乘。
数据结构第3节： 抽象数据类型
最新发布
hummhumm的专栏
07-02 951
ADT定义了数据的逻辑结构和操作，但不涉及数据的具体表示和实现。例如，一个栈的ADT可以定义为具有pushpoppeek和isEmpty等操作。// 入栈操作T pop();// 出栈操作T peek();// 查看栈顶元素// 检查栈是否为空// 入队操作// 出队操作T peek();// 查看队首元素// 检查队列是否为空// 在链表头部添加元素// 在链表尾部添加元素// 移除并返回链表头部的元素// 移除并返回链表尾部的元素// 获取链表头部的元素。
add_to_page_cache_lru函数
06-09
`add_to_page_cache_lru()`函数是Linux内核中用于向页面缓存LRU链表中添加页的函数。它的作用是把一个页添加到LRU链表中，并更新相应的统计信息，以便更好地管理内存。该函数的原型定义如下： ```c void add_to_page_cache_lru(struct page *page, struct address_space *mapping, pgoff_t offset, gfp_t gfp_mask); ``` 其中，`page`参数是待添加到LRU链表的页，`mapping`参数是页所属的地址空间，`offset`参数是页在地址空间中的偏移量，`gfp_mask`参数是内存分配标志，用于指定内存分配时的行为。 该函数内部会将页添加到LRU链表中，并根据需要缩减LRU链表的长度，以保证LRU链表的长度不超过系统预设的最大值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

GR鲸鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值