DS高阶：LRU Cache

最新推荐文章于 2024-06-07 09:45:58 发布
最新推荐文章于 2024-06-07 09:45:58 发布
阅读量994 收藏 148
点赞数 167
分类专栏： 数据结构 文章标签： 数据库 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51142926/article/details/138825447
版权

一、LRU Cache

1.1 什么是LRU Cache

        LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。 什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用
DRAM技术，而使用昂贵但较快速的SRAM技术。 广义上的Cache指的是位于速度相差较大的两种
硬件之间， 用于协调两者数据传输速度差异的结构。除了CPU与主存之间有Cache， 内存与硬盘
之间也有Cache，乃至在硬盘与网络之间也有某种意义上的Cache── 称为Internet临时文件夹或网络内容缓存等。

1.2 LRU Cache的设计思路

       Cache的容量有限，因此当Cache的容量用完后，而又有新的内容需要添加进来时， 就需要挑选并舍弃原有的部分内容，从而腾出空间来放新内容。LRU Cache 的替换原则就是将最近最少使用的内容替换掉。其实，LRU译成最久未使用会更形象， 因为该算法每次替换掉的就是一段时间内最久没有使用过的内容。

我们通过一道OJ题来引入：

. - 力扣（LeetCode）LRU缓存

问题的关键就是底层要如何设计才能达到get和put都达到O（1）的时间复杂度？？

        实现LRU Cache的方法和思路很多，但是要保持高效实现O(1)的put和get，那么使用双向链表和哈希表的搭配是最高效和经典的。使用双向链表是因为双向链表可以实现任意位置O(1)的插入和删除，使用哈希表是因为哈希表的增删查改也是O(1)。
     

       那么用双向带头链表，我们可以让链表的尾部的数据充当最近最少使用的，而平时的新增以及更新都放到链表头部去。但是这样还会存在一个问题就是，我们要插入是O（1）,但是我们要将使用过的节点更新后放到头部的时候，我们没有办法直接O（1）找到需要挪动的节点，需要去遍历获取，那么复杂度就是O（N）了

    所以破局点就在于如果快速找到key对应的节点在list中的存储位置。

      平时我们想要快速找到一个元素在数组中的位置，我们会去存储元素（K）和数组下标（V）的映射关系，但是现在存储数据的不是数组而是链表，那么我们想要知道他的对应数据的位置，我们就可以在哈希表中存迭代器！！然后key对应的value只存在list中

二、LRU Cache的模拟实现

2.1 底层结构的设计

template<class K,class V>
class LRUCache 
{
public:

private:
    typedef typename list<pair<K,V>>::iterator iterator;//迭代器 方便我们快速在链表找到这个节点  取模版的内嵌类型要加typename
    unordered_map<K, iterator> _hashMap;//哈希 存k以及对应的迭代器     做到查找和更新是O(1)
    list<pair<K,V>> _LRUList;//list去存value
    size_t _capacity;
};

 哈希表中存的是key和list的迭代器。

2.2 默认构造

LRUCache(size_t capacity=10) //默认开10个
    :_capacity(capacity)
{}

2.3 get

//看看能否找到这个数据  找到就返回他对应的value 
V get(const K& key)
{
    auto ret = _hashMap.find(key);
    if (ret != _hashMap.end()) //如果找到了 就返回对应关键字对应的value
    {
        iterator it = ret->second;//拿到对应的迭代器
        //因为被使用过了，所以将迭代器放到最前面去
        //方案1：erase一下，但是迭代器会失效，所以需要更新一下然后放到最前面去
        // int value=it->second;
        // _LRUList.push_front(make_pair(key, value));
        //_LRUList.erase(it);
        //_hashMap[key] = _LRUList.begin();//换了个迭代器,所以要更新一下
        //return value;//第一个second拿到迭代器，第二个second拿到的是value
        //方案2：转移过去void splice (const_iterator position, list& x, const_iterator i);
        _LRUList.splice(_LRUList.begin(), _LRUList, it); //被转移的位置   被转移的对象   想转移的迭代器
        return it->second;//第一个second拿到迭代器，第二个second拿到的是value
    }
    else return V();//没找到，返回默认构造
}

 splice 可以将节点转移到指定位置的前面

 如果不用这个函数，那就先删掉然后再继续在头部造一个。

2.4 put


    //如果没有，就是新增，放到头结点的位置  但是如果满了，要先删除最后一个 然后再头插
    //如果有，就是更新，快速找到对应的位置，然后更新之后放到前面去
    void put(const K& key, const V& value)
    {
        auto ret = _hashMap.find(key);
        if (ret == _hashMap.end()) //没有->新增  满了要先删  没满就直接加
        {
            if (_capacity == _hashMap.size()) //不用链表的size是因为有的链表的遍历可能是O（N）
            {
                //删除一下尾节点
                pair<K,V> back = _LRUList.back();
                _LRUList.pop_back();
                _hashMap.erase(back.first);//删除再哈希中的元素
            }
            //进行头插
            _LRUList.push_front(make_pair(key, value));
            _hashMap[key] = _LRUList.begin();
        }
        //这个时候就是更新
        else
        {
            iterator it = ret->second;//拿到迭代器
            it->second = value;//更新一下
            //刚用过，所以迭代器往前移
            _LRUList.splice(_LRUList.begin(), _LRUList, it);
        }
    }

         如果没找到了就是新增->要先判断容量是否满了，如果满了要先删掉尾部的数据，以及对应位置在哈希表中的数据，然后再将新增的头插进去。 

        如果找到了就是更新（我们用哈希存迭代器的作用就体现出来了），我们可以通过哈希快速找到对应的迭代器，然后把他转移到前面去！！！

2.5 打印观察

       直接遍历一下链表中的kv结构就可以判断我们LRUlist是否完成我们的要求

 void Print()//打印LRU的情况 方便观察
 {
     for (auto& e : _LRUList) //e拿到的是pair类型
         cout << "(" << e.first << "," << e.second << ")->";
     cout << "nullptr" << endl;
 }

2.6 测试代码

void test1()
{
    LRUCache<string, string> L(5);
    L.put("sort", "排序");
    L.put("quick", "快速");
    L.put("left", "左边");
    L.put("right", "右边");
    L.Print();
    cout << L.get("sort")<<endl;//1,验证是否可以拿到对应的元素  2，拿到之后是否移到了最前面
    cout << L.get("happy") << endl;
    L.Print();
    L.put("left", "(左边)");//验证更新
    L.Print();
    L.put("hello", "你好");
    L.put("thank", "谢谢");
    L.Print();
}

 2.7 整体代码的实现

#pragma once
#include<iostream>
#include<list>
#include<unordered_map>
#include<string>
using namespace std;

//LRU Cache 最近最少使用缓存要被淘汰掉
//cache  一般用于速度不相同的两个介质之间（缓存）   cpu 内存 磁盘
//局部性原理  我用了当前那块，可能我马上就要用相邻的那块
//put和get都必须是O（1）   ->哈希表
//但是LRU Cache的精髓是选取最近最少用的      那么我们可以用一个链表  那么尾部的默认就是最近最少用的 
//get的时候 如有有就返回，同时因为用过了，所以要将这个用过的放到最前面去。
//put有两种情况，一种是需要先看看关键字有没有，如果有的话就更新一下，然后放到头部去     如果没有的话，要看看是否满了，满了就得先删最后一个元素 然后将新的元素插入到头部去

template<class K,class V>
class LRUCache 
{
public:
    LRUCache(size_t capacity=10) //默认开10个
        :_capacity(capacity)
    {}

    //看看能否找到这个数据  找到就返回他对应的value 
    V get(const K& key)
    {
        auto ret = _hashMap.find(key);
        if (ret != _hashMap.end()) //如果找到了 就返回对应关键字对应的value
        {
            iterator it = ret->second;//拿到对应的迭代器
            //因为被使用过了，所以将迭代器放到最前面去
            //方案1：erase一下，但是迭代器会失效，所以需要更新一下然后放到最前面去
            // int value=it->second;
            // _LRUList.push_front(make_pair(key, value));
            //_LRUList.erase(it);
            //_hashMap[key] = _LRUList.begin();//换了个迭代器,所以要更新一下
            //return value;//第一个second拿到迭代器，第二个second拿到的是value
            //方案2：转移过去void splice (const_iterator position, list& x, const_iterator i);
            _LRUList.splice(_LRUList.begin(), _LRUList, it); //被转移的位置   被转移的对象   想转移的迭代器
            return it->second;//第一个second拿到迭代器，第二个second拿到的是value
        }
        else return V();//没找到，返回默认构造
    }

    //如果没有，就是新增，放到头结点的位置  但是如果满了，要先删除最后一个 然后再头插
    //如果有，就是更新，快速找到对应的位置，然后更新之后放到前面去
    void put(const K& key, const V& value)
    {
        auto ret = _hashMap.find(key);
        if (ret == _hashMap.end()) //没有->新增  满了要先删  没满就直接加
        {
            if (_capacity == _hashMap.size()) //不用链表的size是因为有的链表的遍历可能是O（N）
            {
                //删除一下尾节点
                pair<K,V> back = _LRUList.back();
                _LRUList.pop_back();
                _hashMap.erase(back.first);//删除再哈希中的元素
            }
            //进行头插
            _LRUList.push_front(make_pair(key, value));
            _hashMap[key] = _LRUList.begin();
        }
        //这个时候就是更新
        else
        {
            iterator it = ret->second;//拿到迭代器
            it->second = value;//更新一下
            //刚用过，所以迭代器往前移
            _LRUList.splice(_LRUList.begin(), _LRUList, it);
        }
    }

    void Print()//打印LRU的情况 方便观察
    {
        for (auto& e : _LRUList) //e拿到的是pair类型
            cout << "(" << e.first << "," << e.second << ")->";
        cout << "nullptr" << endl;
    }
private:
    typedef typename list<pair<K,V>>::iterator iterator;//迭代器 方便我们快速在链表找到这个节点  取模版的内嵌类型要加typename
    unordered_map<K, iterator> _hashMap;//哈希 存k以及对应的迭代器     做到查找和更新是O(1)
    list<pair<K,V>> _LRUList;//list去存value
    size_t _capacity;
};



void test1()
{
    LRUCache<string, string> L(5);
    L.put("sort", "排序");
    L.put("quick", "快速");
    L.put("left", "左边");
    L.put("right", "右边");
    L.Print();
    cout << L.get("sort")<<endl;//1,验证是否可以拿到对应的元素  2，拿到之后是否移到了最前面
    cout << L.get("happy") << endl;
    L.Print();
    L.put("left", "(左边)");//验证更新
    L.Print();
    L.put("hello", "你好");
    L.put("thank", "谢谢");
    L.Print();
}

✿༺小陈在拼命༻✿
关注
  • 167
    点赞
  • 踩
  • 148
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 143
    评论
专栏目录
javalruleetcode-LRU_cache:LRU_cache
06-29
java lru leetcode LRU_cache (Leetcode 146) 设计和实现最近最少使用 (LRU) 缓存的数据结构。 它应该支持以下操作：get 和 set。 get(key) – 如果键存在于缓存中，则获取键的值（将始终为正），否则返回 -1。 set(key, value) – 如果键不存在，则设置或插入值。 当缓存达到其容量时，它应该在插入新项目之前使最近最少使用的项目无效。 跟进：你能在 O(1) 时间复杂度内完成这两个操作吗？ 分析 LRU 缓存是将最近使用的项目保留在缓存中，并在缓存达到其容量时丢弃最近最少使用的项目。 因此，应按缓存中的“已用时间”按顺序保存项目。 我们需要跟踪每个项目的使用时间。 当我们调用 get(key) 函数时，除了返回它的值之外，我们还需要将其使用时间更新为最近的。 当我们调用 set(key, value) 函数时，我们也需要更新它的使用时间。 我们可以使用由双链表实现的 Queue 来保存项目。 Queue 中的顺序代表“使用时间”的顺序。 例如，头部表示最近使用的项目，尾部表示最近最少使用的项目。 我们执行“删除”和“
lrucacheleetcode-LRU_Cache:LRU_Cache
06-29
lru缓存leetcode LRU_Cache 灵感来自 LeetCode OJ：
lru-cache-pool:LRU 缓存池
06-05
LRU缓存池 LRU 缓存池。 用法 var LRU = require ( 'lru-cache' ) , LRUPool = require ( 'lru-cache-pool' ) , pool = LRUPool ( LRU ) , c1 , c2 ; c1 = pool . get ( 'users' ) ; c1 . put ( 'z' , 77 ) ; c2 = pool . get ( 'users' ) ; assert . equal ( 77 , c2 . get ( 'z' ) ) ; 选项 可以在构造函数LRUPool(LRU, options)提供选项，也可以在通过 get pool.get('name', options)创建新缓存时提供pool.get('name', options) 。 有关详细信息，请参阅的。 笔记 第一次调用pool
lrucacheleetcode-lru_cache:lru_cache
06-29
lru缓存leetcode LRU缓存 受启发的简单 LRU 缓存实现 发展 建造 ./gradlew build 测试 ./gradlew test 使用示例 LRUCache< String , String > cache = new LRUCache<> ( 2 /* capacity */ ); cache . put( " Hi " , " Hi " ); cache . put( " Bye " , " Bye " ); cache . put( " No " , " No " ); // deletes "Hi" cache . get( " Hi " ) // returns null
machinepack-lrucache:LRU Cache machine-pack
06-15
machinepack-lrucache 具有最少最近使用策略的缓存：当达到最大大小时，缓存具有最大容量大小，并且添加新项目时删除最近最少使用的对象。 安装 $ npm install machinepack-lrucache 用法 该模块的最新使用文档、版本信息和测试状态见 。 为每台机器生成的联机帮助页包含所有预期输入、可能的退出状态和示例返回值的完整参考。 如果您需要更多帮助，或发现错误，请跳入或在项目留言。 关于![Gitter](https://badges.gitter.im/Join Chat.svg) 这是一个machinepack ，一个 NPM 模块，它根据machinepack 规范公开一组相关的 Node.js机器。 此模块中包含的机器（以及 Node.js 的所有其他 NPM 托管机器）的文档页面会自动生成并在公共注册表上保持最新。 了解更多信息 http:
USTB871(DS+CO)
Dlrow Olleh~
09-18 1110
NULL
实战篇3：一切皆对象，文件目录体系（节点树）
weixin_53295593的博客
03-30 2052
AOS与阿里名称冲突，现改为OACS；面向对象汇编语言OASM（Object assembly language），又带一点点C风格，改名为OACS、即是带一点C风格的面向对象汇编语言系统（Object assembly language C system）。一切皆对象，相比unix/linux的一切皆文件，会显得范围更广一些；许多内核对象，如内存对象、CPU对象、IPC对象、线程对象、等等，是没有文件i节点的。c语言功能也强大，但个人认为、想用好并不容易；这段时间，看了不少嵌入式操作系统及相关的源代码；给
Java架构师，大数据架构师，高并发设计模式，机器学习知识点分享
u014033218的专栏
09-14 6609
第一章：java精品课程目录大全 1、亿级流量电商详情页系统的大型高并发与高可用缓存架构实战 1课程介绍以及高并发高可用复杂系统中的缓存架构有哪些东西？32分钟 2基于大型电商网站中的商品详情页系统贯穿的授课思路介绍7分钟 3小型电商网站的商品详情页的页面静态化架构以及其缺陷11分钟
计算机体系结构期末重点,计算机系统结构期末重点题目及考点
weixin_39959615的博客
07-24 1357
《计算机系统结构期末重点题目及考点》由会员分享，可在线阅读，更多相关《计算机系统结构期末重点题目及考点(21页珍藏版)》请在人人文库网上搜索。1、第1章 ：1.2.如有一个经解释实现的计算机，可以按功能划分成4级。每一级为了执行一条指令需要下一级的N条指令解释，若执行第一级的一条指令需kns，那执行第2级、第3级、第4级的指令需要多少时间？第1级 1条1级指令 k ns第2级 1条2级指令 N条1...
计算机组成原理
热门推荐
qq_24925393的博客
08-06 2万+
计算机系统有硬件和软件两部分组成，软件又可分为系统软件和应用软件 硬件：看得见摸得着的电子元器件，如主机，外部设备 软件：人们事先编制的具有特殊功能的程序 程序通常存放在计算机主存储器或者辅存里 直接执行机器语言的程序：实际机器M（机器语言机器） 符号式的程序设计语言：汇编语言（汇编语言机器称为虚拟机器，实际不存在，使人们感受到存在的具有翻译功能的机器，先将汇编语言翻译成机器语言，
计算机系统原理
iku_whf的博客
01-25 617
目录进制(2/8/10/16)原码/反码/补码数的表示整数(int)浮点数(float/double) 进制(2/8/10/16) 用于数字的计算和表示,n进制表示满n进1 进制 用表示的字符集 识别前缀 2 [0-1] 8 [0-7] 0 10 [0-9] 16 [0-9],[a-f] (a-f分别表示10-15，字母大小写均可) 0x，大小写均可 比如 0x12 表示16进制数12 10进制值为18 原码/反码/补码 以32位数举例 符号位：0位正，1位负 原码：第一
计算机组成原理-宝典
发现问题，并解决问题，批判性思维
02-17 1万+
1.移码和补码的关系:同一数值的移码与补码符号位相反,其它各位相同；故0的移码和补码表示形式唯一。
chat4-Server端保存聊天消息到mysql
gulanga5的博客
06-02 830
本文档描述了Server端接收到Client的消息并转发给所有客户端或私发给某个客户端同时将聊天消息保存到mysql服务端为当前客户端创建一个线程，此线程接收当前客户端的消息并转发给所有客户端或私发给某个客户端同时将聊天消息保存到mysql本文档主要总结了将聊天消息保存到mysql!!!),;import;import;import;/**用druid连接池来连接数据库的工具类*/DBUtil。
java中mysql5和mysql8数据库连接方式
Alfred_tfk的博客
06-04 366
java中mysql5和mysql8数据库连接方式。
数智融通 创新发展|亚信科技携AntDB、Data OS与隐私计算产品，赋能企业高质量发展
最新发布
weixin_44518445的博客
06-07 344
AntDB数据库始于2008年，在运营商的核心系统上，服务国内24个省市自治区的数亿用户，具备高性能、弹性扩展、高可靠等产品特性，峰值每秒可处理百万笔通信核心交易，保障系统持续稳定运行超十年，并在通信、金融、交通、能源、物联网等行业成功商用落地。同时，还分享了隐私计算产品在政务、汽车等多个领域展现出广泛的应用潜力，通过隐私求交、隐匿查询等功能，在保障数据安全的同时促进了数据的流通和共享，为各行业数据应用提供了坚实的技术支持，赋能千行百业。集成了数据采集、分析和存储等关键功能，提供了。
【数据库复习】第一章 绪论
AClerk的博客
06-03 619
想你了，牢大
【问题解决】MySQL恢复数据库报错Unknown command ‘\‘‘.
拾级而上
06-01 250
MySQL恢复数据库报错Unknown command '\''.
spark第三篇sql
Emperor_rock的专栏
06-04 1035
sparksql
用java写出：LRU
06-07
LRU（Least Recently Used）是一种缓存淘汰算法，它会优先淘汰最近最少使用的缓存。下面是用Java实现LRU算法的代码： ```java import java.util.HashMap; import java.util.Map; public class LRUCache<K, V> { private final int capacity; private final Map<K, Node<K, V>> cache; private Node<K, V> head; private Node<K, V> tail; public LRUCache(int capacity) { this.capacity = capacity; this.cache = new HashMap<>(capacity); } public V get(K key) { Node<K, V> node = cache.get(key); if (node == null) { return null; } refresh(node); return node.value; } public void put(K key, V value) { Node<K, V> node = cache.get(key); if (node == null) { if (cache.size() == capacity) { cache.remove(tail.key); remove(tail); } node = new Node<>(key, value); cache.put(key, node); add(node); } else { node.value = value; refresh(node); } } private void add(Node<K, V> node) { if (head == null) { head = node; tail = node; } else { node.next = head; head.prev = node; head = node; } } private void remove(Node<K, V> node) { if (node == head) { head = head.next; } else if (node == tail) { tail = tail.prev; } else { node.prev.next = node.next; node.next.prev = node.prev; } } private void refresh(Node<K, V> node) { remove(node); add(node); } private static class Node<K, V> { private final K key; private V value; private Node<K, V> prev; private Node<K, V> next; public Node(K key, V value) { this.key = key; this.value = value; } } } ``` 使用方法： ```java LRUCache<Integer, String> cache = new LRUCache<>(2); cache.put(1, "one"); cache.put(2, "two"); System.out.println(cache.get(1)); // 输出：one cache.put(3, "three"); System.out.println(cache.get(2)); // 输出：null cache.put(4, "four"); System.out.println(cache.get(1)); // 输出：null System.out.println(cache.get(3)); // 输出：three System.out.println(cache.get(4)); // 输出：four ``` 上面的代码中，LRUCache类封装了一个双向链表和一个哈希表。哈希表用来存储键值对，双向链表用来维护缓存中的元素顺序。在get方法中，如果缓存中不存在指定的键，则返回null；否则，将与该键对应的节点移到链表头部，并返回节点的值。在put方法中，如果缓存已满，则删除链表尾部的节点，并从哈希表中删除对应的键值对；否则，将新节点添加到链表头部，并在哈希表中存储新的键值对。在refresh方法中，先将节点从链表中删除，然后再将其添加到链表头部，以保证链表中最近访问的节点总是在链表头部。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

✿༺小陈在拼命༻✿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值