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

最新推荐文章于 2024-11-10 23:39:48 发布
最新推荐文章于 2024-11-10 23:39:48 发布
阅读量1k 收藏 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鲸鱼
关注
专栏目录
lru-cache：C ++中功能完整的LRU缓存实现
02-05
在C++中实现LRU缓存，需要理解数据结构和算法的基础知识，特别是哈希表和双向链表的应用。 在C++中，LRU缓存通常通过结合哈希表（如`std::unordered_map`）和双向链表（如`std::list`或自定义实现）来实现。哈希表...
【深入理解LRU Cache】：缓存算法的经典之作
StuLearn-LJC的博客
03-07 5422
​LRU Cache（Least Recently Used的缩写，即最近最少使用，它是一种Cache的替换算法。看Cache替换算法这篇文章）是一种常见的缓存淘汰算法。用于在有限的缓存空间中管理数据对象。LRU Cache 的核心思想是基于时间局部性原理，即最近被访问的数据在未来可能会被再次访问。
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 进行安装
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.rar_LRU_lru 算法_lru算法
09-23
在编程语言中，LRU缓存的实现通常会用到数据结构如Java的`LinkedHashMap`，Python的`collections.OrderedDict`等，它们能方便地实现按访问顺序更新的数据结构。 LRU算法的优点在于其简单性和高效性，它能在大多数...
二叉树遍历/算法&数据结构
2403_86942375的博客
11-10 666
其实很简单，根据遍历的顺序摆放遍历顺序和添加元素的顺序，(root.left, result)代表左子树，(root.right, result)代表右子树，(root.val)代表中节点。其实很简单，参数就是要目前遍历节点在哪，返回值也同理，终止条件就是指遍历到null的时候回溯，逻辑不要想复杂，根据顺序移动上述上个递归函数即可。前序（要理解遍历的核心，先把中节点塞入，然后根据栈去模拟，先加入右节点然后是左节点，移动到左节点继续加入）后序（就是前序遍历的左右调换顺序，然后再倒叙结果数组）
【初阶数据结构篇】二叉树OJ题
braveact的博客
11-10 447
根节点与左右孩子的数值进行比较，如果相等依次递归左右子树，如果为空，或者两者对应的值相等，则返回true。🚀 分享给更多人：如果你觉得这篇文章对你有帮助，欢迎分享给更多对C++感兴趣的朋友，让我们一起进步！可以将该二叉树看成两个独立的二叉树，分别将“两个二叉树”的根节点传入，判断该是否为相同的二叉树。将两个数的根节点的值依次比较，依次递归两根节点的左子树，若根节点为空，直接返回。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。期待你的三连，你的支持就是我创作的动力！
开放寻址法、链式哈希数据结构详细解读
m0_61840987的博客
11-06 941
开放寻址法在低负载因子时效率较高，而链式哈希在高负载因子下表现更稳定。
【数据结构】B树
藓类少女的博客
11-06 885
B树通常定义为一棵平衡的多路搜索树，并用一个整数 m 表示其阶数，即每个节点最多有 m 个子节点。每个节点最多包含 m - 1 个关键字和 m 个子节点。每个非根节点至少包含 ⌈m/2⌉−1 个关键字和 ⌈m/2⌉ 个子节点。根节点至少包含 1 个关键字，特殊情况除外（当树为空时，根节点没有关键字）。所有叶子节点都在同一层，即 B 树的高度是均匀的。每个节点的关键字从小到大排序，并且遵循左小右大的原则。每个关键字 k 的左子树的所有关键字都小于 k，右子树的所有关键字都大于 k。
希尔排序算法
a921876874的博客
11-06 965
希尔排序算法
python中常见的8种数据结构之一数组的应用
2301_81121233的博客
11-10 221
可能的类型码包括`b`（有符号整数）、`B`（无符号整数）、`u`（Unicode字符）、`h`（有符号短整数）、`H`（无符号短整数）、`i`（有符号整数）、`I`（无符号整数）、`l`（有符号长整数）、`L`（无符号长整数）、`f`（浮点数）、`d`（双精度浮点数）等。数组和列表的主要区别在于数组中的元素必须是同一种类型，而列表中的元素可以是任何类型。可以通过索引访问数组中的元素，也可以使用切片操作来获取数组的子集。3.音频处理：音频数据通常也以数组的形式存储，数组可以用来处理音频的采样值。
【01课_初识算法与数据结构】
weixin_42333261的博客
11-10 637
算法，个人理解就是计算一段逻辑，最简化，最快速的方式、方法每个函数，就包含了一定的算法，执行一定的计算逻辑。
Java进阶嵌套循环：十.冒泡与选择算法排序
2301_77163982的博客
11-06 271
使用冒泡与选择算法实现数组的排序
数据结构中数据有序性/ 单调性 ——二分查找
最新发布
weixin_64842400的博客
11-10 439
最后返回的时候，返回left / right+ 1都可，因为最后的情况一定是 left == right ，然后mid =left =right，然后right = mid -1 = left -1；如果left == right ，我们始终明确一点：【L，R】中的数字是不确定的，也就是nums[left]==nums[right] 这一个数字，我们还没验呢！给你一个仅由整数组成的有序数组，其中每个元素都会出现两次，唯有一个数只会出现一次。请你找出给定目标值在数组中的开始位置和结束位置。
python中常见的8种数据结构之一列表
2301_81121233的博客
11-10 632
示例：```del my_list[2] # 删除第三个元素``` 或者 ```my_list.remove(3) # 删除元素3```示例：```my_list = []``` 或者 ```my_list = [1, 2, 3]```示例：```print(my_list[1:3]) # 输出从第二个元素到第三个元素的切片```示例：```print(len(my_list)) # 输出列表的长度```示例：```print(my_list[0]) # 输出第一个元素```
【数据结构】交换排序——冒泡排序 和 快速排序
2302_79968411的博客
11-10 520
其实经过学习，快速排序其实在发明之初并不是最快的但是经过多轮改进快速排序已经被存在了 c 语言库中就是qsort这是 c 语言库中的快排我讲的那两个优化比较简单所以这里挖个坑对于快速排序对重复数据较多的数据排序方法三路划分以及防止栈溢出，非递归解决方法栈模拟递归这些我后面会陆续发出来的因为要是一起就篇幅太大了。
95.【C语言】数据结构之双向链表的头插,头删,查找,中间插入,中间删除和销毁函数
2401_85828611的博客
11-10 435
1.双向链表的头插 　 方法一 　 方法二 2.双向链表的头删 3.双向链表的销毁 4.双向链表的某个节点的数据查找 5.双向链表的中间插入 5.双向链表的中间删除 6.对比顺序表和链表
【C++】算法与数据结构--最长连续串
weixin_40293999的博客
11-10 69
而s2 仅仅会跑 1—>5 2–> 1 发现在集合里就jump了 同理3–>2, 4–>3 …这里面用两个方法解决了这个问题，但是第一个方法不太好，时间复杂度高，在真正跑力扣的时候有一个用例会超时，这是因为。的时候， s1 会 1—>5, 2–>5, 3–>5, 4–>5, 5, 这样子都跑。当遇到【1，2，3，4，5，7，8，9】
add_to_page_cache_lru函数
06-09
`add_to_page_cache_lru()`函数是Linux内核中用于向页面缓存LRU链表中添加页的函数。它的作用是把一个页添加到LRU链表中，并更新相应的统计信息，以便更好地管理内存。该函数的原型定义如下： ```c void add_to_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

GR鲸鱼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值