【高阶数据结构】LRUCache

于 2024-03-02 16:36:49 发布
阅读量924 收藏 19
点赞数 19
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73888323/article/details/136061411
版权
本文介绍了LRUCache的工作原理，如何利用双向链表和哈希表实现高效O(1)的put和get操作，并对比了LinkedHashMap的不同accessOrder设置。同时，给出了LeetCodeLRUCache问题的解题思路和两种Java代码实现方式。
摘要由CSDN通过智能技术生成

文章目录

1. 什么是LRU Cache

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

然而，由于缓存的容量有限，当缓存满了之后，就需要选择一种策略来替换掉部分缓存数据，以便为新数据腾出空间。LRUCache就是其中一种常用的缓存替换策略。LRUCache 的替换原则就是将最近最少使用的内容替换掉。其实 LRU 译为最久未使用更形象，因为该算法每次替换掉的就是一段时间内最久没有使用过的内容。

2. LRU Cache的实现

实现 LRU Cache 的方法和思路有很多，但是要保证高效实现 O(1) 的 put 和 get，那么使用双向链表和哈希表是最高效和经典的。使用双向链表可以保证在任务位置实现插入和删除的时候都能达到 O(1)，使用哈希表是因为使用哈希表的增删查改的时间复杂度是 O(1)。

在这里插入图片描述

3. LinkedHashMap

在 JDK 中也存在类似 LRU Cache 的数据结构——LinkedHashMap。

在这里插入图片描述
LinkedHashMap 有下面几种构造方法：

构造方法一：

public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
    accessOrder = false;
}

构造方法二：

public LinkedHashMap(int initialCapacity) {
    super(initialCapacity);
    accessOrder = false;
}

构造方法三：

public LinkedHashMap() {
    super();
    accessOrder = false;
}

构造方法四：

public LinkedHashMap(Map<? extends K, ? extends V> m) {
    super();
    accessOrder = false;
    putMapEntries(m, false);
}

构造方法五：

public LinkedHashMap(int initialCapacity,
                     float loadFactor,
                     boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

参数说明：

  1. initialCapacity：初始容量大小，使用无参数构造方法的时候，此值默认是16
  2. loadFactor：加载因子，使用无参数构造方法的时候，此值默认为0.75f
  3. accessOrder false：基于插入顺序 true：基于访问顺序
  4. map：哈希表，该构造方法常用于将哈希表转为 LinkedHashMap 操作

这里 initialCapacity、loadFactor 和 map 都好理解，接下来我们看看当 accessOrder 的值为 false 和 true 的区别：

public class Main {
    public static void main(String[] args) {
        Map<String,String> map = new LinkedHashMap<>(16,0.75f,false);
        map.put("1","a");
        map.put("2","b");
        map.put("5","f");
        map.put("4","e");
        map.put("3","c");

        System.out.println(map.get("5"));
        System.out.println(map);
    }
}

在这里插入图片描述

可以看到当我们的 accessOrder 为 false 的时候，不管我们如何访问 LinkedHashMap 中的数据，最后 LinkedHashMap 中数据的顺序还是按照插入时候的顺序排序的。

而我们将 accessOrder 改为 true 的时候，再访问其中的数据，就会发现 LInkedHashMap 中数据的顺序就发生了变化：

public class Main {
    public static void main(String[] args) {
        Map<String,String> map = new LinkedHashMap<>(16,0.75f,true);
        map.put("1","a");
        map.put("2","b");
        map.put("5","f");
        map.put("4","e");
        map.put("3","c");

        System.out.println(map.get("5"));
        System.out.println(map);
    }
}

在这里插入图片描述

当 accessOrder 为 true 的时候，LinkedHashMap 中数据的顺序就是根据访问顺序来的，如果你访问了一个数据，那么该数据就会被放到双向链表的末尾。

4. LRU Cache OJ题

https://leetcode.cn/problems/lru-cache/description/

4.1 题目要求

请你设计并实现一个满足 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 <= 105
最多调用 2 * 105 次 get 和 put

class LRUCache {

    public LRUCache(int capacity) {
        
    }
    
    public int get(int key) {

    }
    
    public 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);
 */

4.2 解题思路

这道题目我们可以直接继承 LinkedHashMap 类，然后重写父类中的方法就可以了。当然我们也可以自己实现一个 LinkedHashMap 类。

4.3 代码实现

4.3.1 Java代码一

class LRUCache extends LinkedHashMap<Integer,Integer>{
    private int capacity;
    public LRUCache(int capacity) {
        super(capacity,0.75f,true);
        this.capacity = capacity;
    }
    
    public int get(int key) {
        return super.getOrDefault(key,-1);
    }
    
    public void put(int key, int value) {
        super.put(key,value);
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        return size() > capacity;
    }
}

/**
 * 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);
 */

在这里插入图片描述

4.3.2 Java代码二

class LRUCache {

    static class DLinkNode {
        public int key;
        public int val;
        public DLinkNode prev;
        public DLinkNode next;
        public DLinkNode() {

        }
        public DLinkNode(int key, int val) {
            this.key = key;
            this.val = val;
        }

        @Override
        public String toString() {
            return  "{ key=" + key +", val=" + val+"} ";
        }
    }

    public DLinkNode head;//双向链表的头节点
    public DLinkNode tail;//双向链表的尾巴节点
    public int usedSize;//代表当前双向链表当中 有效的数据个数
    public Map<Integer,DLinkNode> cache;//定义一个map
    public int capacity;//容量


    public LRUCache(int capacity) {
        this.head = new DLinkNode();
        this.tail = new DLinkNode();
        head.next = tail;
        tail.prev = head;
        cache = new HashMap<>();
        this.capacity = capacity;
    }

    /**
     * 存储元素
     * 1. 查找当前的这个key 是不是存储过
     * @param key
     * @param val
     */
    public void put(int key,int val) {
        //1. 查找当前的这个key 是不是存储过
        DLinkNode node = cache.get(key);
        //2. 如果没有存储过
        if(node == null) {
            //2.1 需要实例化一个节点
            DLinkNode dLinkNode = new DLinkNode(key,val);
            //2.2 存储到map当中一份
            cache.put(key,dLinkNode);
            //2.3 把该节点存储到链表的尾巴
            addToTail(dLinkNode);
            usedSize++;
            //2.4 检查当前双向链表的有效数据个数 是不是超过了capacity
            if(usedSize > capacity) {
                //2.5 超过了，就需要移除头部的节点
                DLinkNode remNode = removeHead();
                //2.6 清楚cache当中的元素
                cache.remove(remNode.key);
                //2.7 usedSize--;
                usedSize--;
            }
        }else {
            //3. 如果存储过
            //3.1 更新这个key对应的value
            node.val = val;
            //3.2 然后将该节点，移动至尾巴处【因为这个是新插入的数据】
            moveToTail(node);
        }
    }

    /**
     * 移除当前节点到尾巴节点
     * 逻辑：先删除  后添加到尾巴
     * @param node
     */
    private void moveToTail(DLinkNode node) {
        //1. 先删除这个节点
        removeNode(node);
        //2. 添加到尾巴节点
        addToTail(node);
    }

    /**
     * 删除指定节点
     * @param node
     */
    private void removeNode(DLinkNode node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }
    /**
     * 添加节点到链表的尾部
     * @param node
     */
    private void addToTail(DLinkNode node) {
        tail.prev.next = node;
        node.prev = tail.prev;
        node.next = tail;
        tail.prev = node;
    }

    private DLinkNode removeHead() {
        DLinkNode del = head.next;
        head.next = del.next;
        del.next.prev = head;
        return del;
    }


    /**
     * 访问当前的key
     *   逻辑：把你访问的节点 放到尾巴
     * @param key
     * @return
     */
    public int get(int key) {
        DLinkNode node = cache.get(key);
        if(node == null) {
            return -1;
        }
        //把最近 最多使用的 放到了链表的尾巴
        moveToTail(node);
        return node.val;
    }
}

/**
 * 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);
 */

在这里插入图片描述

不能再留遗憾了
关注
  • 19
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
本资料包"初阶数据结构+高阶数据结构，分别用c、c++来实现.zip"包含了使用C和C++语言实现的数据结构实例，旨在帮助初学者和进阶者深化对数据结构的理解。 首先，让我们从初阶数据结构开始。基础的数据结构通常包括...
Java——LRUCache
m0_60867520的博客
12-18 1170
LRUCache的概念，底层逻辑，JDK中的LinkedHashMap的使用，通过LinkedHashMap实现LRUCache，自己通过链表和哈希表实现LRUCache，附带详细代码
java实现LRU缓存淘汰算法
西凉的悲伤博客
10-29 2809
LRU算法：最近最少使用淘汰算法（Least Recently Used）。LRU是淘汰最长时间没有被使用的缓存（即使该缓存被访问的次数最多）。 代码如下： import java.util.*; public class LRUCache { int cap;//最大缓存的数量 Map<String, String> values;//缓存 Set<String> position;//缓存的key,按照存入的顺序存储 public LRUCa
146. LRU 缓存(Java)，详细注释版
打孔员的博客
03-17 191
146. LRU 缓存(Java)，详细注释版
数据结构：LRU Cache
最新发布
海绵宝宝de派小星的博客
12-18 2564
LRU Cache
Java中的LRU缓存算法
QYgujingjing的专栏
07-24 1431
LRU（Least Recently Used）缓存算法是一种常见的缓存淘汰算法，用于在缓存空间不足时决定哪些数据需要被淘汰，以便为新的数据腾出空间。LRU算法的基本思想是：当缓存满时，淘汰最近最少使用的数据，即最长时间没有被访问的数据。在Java中，可以使用LinkedHashMap来实现LRU缓存。LinkedHashMap是Java中的一个哈希表数据结构，它继承自HashMap，但是在内部使用双向链表维护元素的插入顺序。这样，在LinkedHashMap中，元素的遍历顺序与插入顺序是一致的。
matlab基于高阶统计量 去噪
06-09
1. **数据预处理**：读取图像并将其转换为灰度图像，因为高阶统计量通常应用于一维数据。 2. **噪声建模**：模拟或估计图像中的高斯噪声水平。 3. **高阶统计量计算**：计算图像的高阶统计量，如四阶矩（偏度和峰度...
高阶累积量matlab源码
01-25
MATLAB是一种流行的数值计算和数据可视化环境，它为实现高阶累积量的计算提供了丰富的工具箱和函数。在提供的MATLAB源码中，可能包含了以下几个关键步骤： 1. **数据预处理**：首先，原始的数字调制信号可能需要...
MATLAB高阶谱工具箱
05-16
除了上述提到的关键函数，MATLAB高阶谱工具箱还可能包含其他辅助函数，如用于数据预处理、结果可视化和参数调整的函数。这些工具可以帮助用户更方便地进行数据分析，如滤波、去噪、谱估计和结果解释。 六、应用场景...
用Java实现LRUCache的2种方式
沈小洋
11-02 478
自己实现双向链表节点Node，再基于Node节点实现一个双向链表DoubleList，配合HashMap可以比较简单地实现一个LRUCache。框架搭好之后，实现起来相对是比较简单的。这里把最近最少使用的元素放在链表的头部，细节上，Node是双向链表，且必须同时存储key和value。在删除最近最少使用元素时，需要使用Node的key去哈希表中删除对应的元素。
LRU Cache
wusecaiyun的专栏
08-20 418
LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。 什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。 广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。除了CPU与主存之间有Cache， 内存与硬盘之间也
实现LRU Cache（java版）
不清不慎的博客
07-07 2819
LRU算法，也叫最近最少使用算法，我们可以使用该算法来实现cache机制，简单地说就是缓存一定量的数据，当超过设定阀值的时候就把一些过期的数据删除掉，本篇文章我们来看看如何实现LRU Cache，下面我们使用两种方式来实现。 基于LinkedHashMap 在java的集合类中有LinkedHashMap类，当参数accessOrder为true的时候，就会按照访问顺序排序，最后访问的放在最前面，...
LRU Cache数据结构简介
dltvtl1977的博客
11-25 259
什么是LRU Cache 　　LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。 什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。 广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。除了CPU...
Java进阶篇缓存底层设计(LRU、LFU、FIFOCache)
Dream_it_possible！的博客
04-17 2732
采用策略模式和工厂模式生成并创建缓存 函数式编程的应用 有效加锁提升并发能力 通过降低锁粒度提升并发能力 读多写少的场景采用乐观锁
lru规则java_Java实现简单LRU缓存机制的方法
weixin_30550287的博客
02-13 382
一、什么是 LRU 算法就是一种缓存淘汰策略。计算机的缓存容量有限，如果缓存满了就要删除一些内容，给新内容腾位置。但问题是，删除哪些内容呢？我们肯定希望删掉哪些没什么用的缓存，而把有用的数据继续留在缓存里，方便之后继续使用。LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。二、LRU的使用LRUCache cache ...
如何在Java中实现LRU缓存
JavaShark的博客
06-29 1554
最近使用最少（LRU）缓存是一种缓存逐出算法，它按使用顺序组织元素。顾名思义，在LRU中，最长时间未使用的元素将从缓存中逐出。例如，如果我们有一个容量为三项的缓存：最初，缓存是空的，我们将元素 放在缓存中。元素 和 像以前一样被缓存。但现在，缓存容量已满，要放入下一个元素，我们必须逐出缓存中最近使用最少的元素。在我们用Java实现LRU缓存之前，最好先了解一下缓存的一些方面： O（1） LRU缓存的结构 现在，让我们考虑一个有助于我们设计缓存的问题。我们如何设计一个可以在固定时间内执行读取、排序
高阶数据结构之LRU Cache
蔡欣致的个人博客
02-23 672
不会数据结构的程序猿不是合格的程序猿，简单总结LRU Cache相关知识点~
LRU Cache的数据结构选择以及实现
loreal8的博客
10-23 617
LRU LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。 什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。 广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。除了CPU与主存之间有Cache， 内存与硬盘之间也有Cache，乃至在硬盘与网络之间也有某种意义上的Cache── 称为Internet临时文件夹或网络内
LRU算法（JAVA实现）
上山的人
05-10 9863
一、算法介绍 最近最久未使用（Least Recently Used LRU）算法是⼀种缓存淘汰策略，它是大部分操作系统为最大化页面命中率而广泛采用的一种页面置换算法。该算法的思路是，发生缺页中断时，将最近一段时间内最久未使用的页面置换出去。 从程序运行的原理来看，最近最久未使用算法是比较接近理想的一种页面置换算法，这种算法既充分利用了内存中页面调用的历史信息，又正确反映了程序的局部问题。 虚拟页式存储管理，则是将进程所需空间划分为多个页面，内存中只存放当前所需页面，其余页面放入外存的管理方式。 ..
TypeScript高阶数据结构与算法
07-25
TypeScript是一种静态类型的编程语言，它提供了丰富的类型系统和面向对象的特性，使得开发者可以更好地组织和管理代码。在TypeScript中，高阶数据结构和算法可以通过类和泛型等特性来实现。 高阶数据结构是指那些在基本数据结构的基础上进行扩展或组合得到的数据结构。例如，堆、图、树等都可以被视为高阶数据结构。在TypeScript中，我们可以使用类来定义这些高阶数据结构，并通过泛型来指定其内部存储的数据类型。 下面是一个使用TypeScript实现的堆（Heap）数据结构的示例： ```typescript class Heap<T> { private data: T[] = []; public size(): number { return this.data.length; } public isEmpty(): boolean { return this.data.length === 0; } public insert(value: T): void { this.data.push(value); this.siftUp(this.data.length - 1); } public extractMin(): T | null { if (this.isEmpty()) { return null; } const min = this.data[0]; const last = this.data.pop()!; if (!this.isEmpty()) { this.data[0] = last; this.siftDown(0); } return min; } private siftUp(index: number): void { while (index > 0) { const parentIndex = Math.floor((index - 1) / 2); if (this.data[index] >= this.data[parentIndex]) { break; } [this.data[index], this.data[parentIndex]] = [this.data[parentIndex], this.data[index]]; index = parentIndex; } } private siftDown(index: number): void { const size = this.size(); while (index * 2 + 1 < size) { let childIndex = index * 2 + 1; if (childIndex + 1 < size && this.data[childIndex + 1] < this.data[childIndex]) { childIndex++; } if (this.data[index] <= this.data[childIndex]) { break; } [this.data[index], this.data[childIndex]] = [this.data[childIndex], this.data[index]]; index = childIndex; } } } ``` 以上是一个最小堆的实现，使用了数组来存储数据，并提供了插入和提取最小值的操作。堆是一种常见的高阶数据结构，用于解决许多问题，如优先队列和排序等。 通过使用TypeScript，我们可以更加清晰地定义和使用高阶数据结构和算法，并通过类型检查来减少错误和提高代码的可维护性。当然，这只是其中的一个例子，还有许多其他高阶数据结构和算法可以在TypeScript中实现。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

不能再留遗憾了

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

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

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

打赏作者

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

抵扣说明：

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

余额充值