LRU Cache 三步优化方案

最新推荐文章于 2024-09-19 22:26:19 发布
最新推荐文章于 2024-09-19 22:26:19 发布
阅读量881 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 列表 链表 java 数据结构 hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40788718/article/details/108015964
版权

LRU Cache

首先说明这是携程2019年后端的笔试题

https://www.nowcoder.com/question/next?pid=16620108&qid=365880&tid=35966796

时间限制：C/C++ 1秒，其他语言2秒

空间限制：C/C++ 64M，其他语言128M

复制代码

  ``设计一个数据结构，实现LRU Cache的功能(Least Recently Used – 最近最少使用缓存)。它支持如下``2``个操作： get 和 put。` `int` `get(``int` `key) – 如果key已存在，则返回key对应的值value（始终大于``0``）；如果key不存在，则返回-``1``。``void` `put(``int` `key, ``int` `value) – 如果key不存在，将value插入；如果key已存在，则使用value替换原先已经存在的值。如果容量达到了限制，LRU Cache需要在插入新元素之前，将最近最少使用的元素删除。` `请特别注意“使用”的定义：新插入或获取key视为被使用一次；而将已经存在的值替换更新，不算被使用。` `限制：请在O(``1``)的时间复杂度内完成上述``2``个操作。
输入描述:
第一行读入一个整数n，表示LRU Cache的容量限制。 从第二行开始一直到文件末尾，每1行代表1个操作。如果每行的第1个字符是p，则该字符后面会跟随2个整数，表示put操作的key和value。如果每行的第1个字符是g，则该字符后面会跟随1个整数，表示get操作的key。
输出描述:
按照输入中get操作出现的顺序，按行输出get操作的返回结果。
输入例子1:
2
p 1 1
p 2 2
g 1
p 2 102
p 3 3
g 1
g 2
g 3
输出例子1:
1
1
-1
3
例子说明1:
2        //Cache容量为2
p 1 1    //put(1, 1)
p 2 2    //put(2, 2)
g 1      //get(1), 返回1
p 2 102  //put(2, 102)，更新已存在的key，不算被使用
p 3 3    //put(3, 3)，容量超过限制，将最近最少使用的key=2清除
g 1      //get(1), 返回1
g 2      //get(2), 返回-1
g 3      //get(3), 返回3

第一版 —— 链表 （ get、put操作时间复杂度不为O(1)）


import java.util.Scanner;

/**
 * @author gyh
 * @csdn https://blog.csdn.net/qq_40788718
 * @date 2020/8/14 21:31
 */

public class LRUTest {
	/** 双向链表 */
    static class Node{
        private int key ;
        private int value ;
        private Node pred ;
        private Node next ;

        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    static class LRU{
        /** 头节点 */
        private Node head ;
        /** 尾节点 */
        private Node tail ;
        /** 链表的固定容量 */
        private int capacity ;
        /** 链表实际长度 */
        private int size ;

        public LRU(int capacity){
            this.capacity = capacity ;
            this.size = 0 ;
            this.head = new Node(-1 , -1) ;
        }

        public int get(int key){
            Node node = search(key) ;
            //跳出来可能为空 或者找到key了
            if (node != null){
                delete(node);
                insert(node);
                return node.value ;
            }
            return -1 ;
        }

        public void put(int key , int value){
            Node node = search(key) ;
            if (node != null){
                node.value = value ;
                return ;
            }
            node = new Node(key , value) ;
          	//头插入
            insert(node) ;
            if (size > capacity){
                //尾删除
                delete(tail);
            }
        }

        private Node search(int key) {
            Node pre = head.next ;
            while(pre != null && pre.key != key){
                pre = pre.next ;
            }
            return pre ;
        }

        private void insert(Node node){
            Node second = head.next ;
            head.next = node ;
            node.pred = head ;
            node.next = second ;
            if (second != null){
                second.pred = node ;
            }else {
                tail = node ;
            }
            this.size ++ ;
        }

        private void delete(Node node){
            if (node == null){
                return ;
            }
            Node pred = node.pred ;
            Node next = node.next ;
            pred.next = next ;
            if (next != null){
                //node不是队尾
                next.pred = pred ;
            }else{
                this.tail = pred ;
            }
            node.pred = null ;
            node.next = null ;
            this.size -- ;
        }

        public void print(){
            System.out.println("====================");
            Node pre = head.next ;
            while(pre != null){
                System.out.println(pre.key + " " +pre.value);
                pre = pre.next ;
            }
            System.out.println("====================");
        }
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in) ;
        LRU lru = new LRU(input.nextInt()) ;
        while(input.hasNext()){
            String choose = input.next() ;
            if ("p".equals(choose)){
                lru.put(input.nextInt() , input.nextInt());
            }else if ("g".equals(choose)){
                System.out.println(lru.get(input.nextInt())) ;
            }
            lru.print();
        }
    }
}

第二版 —— 链表+ 散列表（符合要求）

import java.util.HashMap;
import java.util.Scanner;

/**
 * @author gyh
 * @csdn https://blog.csdn.net/qq_40788718
 * @date 2020/8/14 21:31
 */

public class LRUTest {

    static class Node{
        private int key ;
        private int value ;
        private Node pred ;
        private Node next ;

        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    static class LRU{
        private Node head ;

        private Node tail ;
        // 加入 hashMap 用于 查找
        private HashMap<Integer , Node> map ;

        private int capacity ;

        private int size ;

        public LRU(int capacity){
            this.map = new HashMap<>();
            this.capacity = capacity ;
            this.size = 0 ;
            this.head = new Node(-1 , -1) ;
        }

        public int get(int key){
            Node node = map.get(key) ;
            //跳出来可能为空 或者找到key了
            if (node != null){
                delete(node);
                insert(node);
                return node.value ;
            }
            return -1 ;
        }

        public void put(int key , int value){
            //Node node = search(key)
            Node node = map.get(key) ;
            if (node != null){
                node.value = value ;
                return ;
            }

            node = new Node(key , value) ;
            insert(node) ;
            if (size > capacity){
                delete(tail);
            }
        }

        private void insert(Node node){
            Node second = head.next ;
            head.next = node ;
            node.pred = head ;
            node.next = second ;
            if (second != null){
                second.pred = node ;
            }else {
                tail = node ;
            }
            map.put(node.key , node) ;
            this.size ++ ;
        }

        private void delete(Node node){
            if (node == null){
                return ;
            }
            Node pred = node.pred ;
            Node next = node.next ;
            pred.next = next ;
            if (next != null){
                //node不是队尾
                next.pred = pred ;
            }else{
                this.tail = pred ;
            }
            node.pred = null ;
            node.next = null ;
            map.remove(node.key) ;
            this.size -- ;
        }

        public void print(){
            System.out.println("====================");
            Node pre = head.next ;
            while(pre != null){
                System.out.println(pre.key + " " +pre.value);
                pre = pre.next ;
            }
            System.out.println("====================");
        }
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in) ;
        LRU lru = new LRU(input.nextInt()) ;
        while(input.hasNext()){
            String choose = input.next() ;
            if ("p".equals(choose)){
                lru.put(input.nextInt() , input.nextInt());
            }else if ("g".equals(choose)){
                System.out.println(lru.get(input.nextInt())) ;
            }
            lru.print();
        }
    }
}

第三版 —— 有序散列表（LinkedHashMap）

package ctrip;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Scanner;

/**
 * @author gyh
 * @csdn https://blog.csdn.net/qq_40788718
 * @date 2020/8/14 21:31
 */

public class Third {

    // 省略 LRU


    static class LRULinkedHashMap extends LRU {

        private LinkedHashMap<Integer , Integer> cache ;

        private int capacity = 0 ;

        public LRULinkedHashMap(int capacity){
            super(capacity);
            cache=new LinkedHashMap<Integer,Integer>(capacity,0.75f,true){
                @Override
                protected boolean removeEldestEntry(java.util.Map.Entry<Integer, Integer> eldest) {
                    return size()>capacity;
                }
            };
        }

        @Override
        public int get(int key){
            return cache.getOrDefault(key , -1);
        }

        @Override
        public void put(int key , int value){
            cache.put(key , value) ;
        }
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in) ;
        LRU lru = new LRULinkedHashMap(input.nextInt()) ;
        while(input.hasNext()){
            String choose = input.next() ;
            if ("p".equals(choose)){
                lru.put(input.nextInt() , input.nextInt());
            }else if ("g".equals(choose)){
                System.out.println(lru.get(input.nextInt())) ;
            }
            lru.print();
        }
    }
}
Python性能加速器：掌握functools.lru_cache装饰器
windowshht的博客
07-26 764
lru_cache装饰器接受一个可选的maxsize参数，用于指定缓存的最大容量。当缓存项的数量超过这个值时，最久未被访问的缓存项将被移除。如果maxsize设置为None，则缓存大小将没有限制（但请注意，这可能会导致内存使用过多）。# 假设这里有一个复杂的计算过程是Python中一个非常实用的装饰器，它通过缓存函数结果的方式，能够显著提高那些重复计算相同输入值的函数的性能。本文详细介绍了lru_cache。
掌握Python性能优化利器：`functools.lru_cache`装饰器的深度应用
windowshht的博客
07-30 587
lru_cache（最近最少使用缓存）是一个装饰器，用于缓存函数调用的结果。当函数被带有不同参数再次调用时，lru_cache会检查缓存中是否已存储了相同参数组合的结果。如果找到，则直接返回缓存中的结果，避免了重复的计算过程，从而显著提高程序运行效率。lru_cache采用LRU（Least Recently Used）算法管理缓存，即当缓存达到设定的容量限制时，会移除最久未被访问的数据项，为新的数据腾出空间。
LRU算法介绍、优化、使用场景(Redis、MySQL、Memcached)
Kindle_code的专栏
08-05 3027
是的
基于闪存数据库的CCF-LRU算法优化
Zuoerfeng
11-13 2154
2018.5.28 今天查看了关于flashdb中关于缓存算法的数据结构，发现了3dsim的数据结构是不一样的，然后又去看了一遍3Dsim的数据结构，发现flashdb的数据结构实际是可以优化的。下面对这个点简单的分析下。 首先来看下flashdb的数据结构 ftop是模拟内存的顺序存储 ptop是哈希表 LRU链表是缓存替换算法 其中引入的frame_id可以看做是数据在内存中的地址。 首先数...
LRU Cache
最新发布
qq_67582098的博客
09-19 971
LRU Cache
如何用Redis缓存改善数据库查询性能？
weixin_33850890的博客
08-02 829
调整一个关系型数据库以实现高性能查询是一个困难的工作。如果优化数据模型和调整查询方式都不起作用，那么管理员可以使用一个诸如Redis这样的缓存技术，这是一个提供内存内和持久数据存储的关键值数据存储方法。 因为Redis具有在数据存储中快速读写数据的能力，所以它比关系型数据库更具有性能优势。但是，关键值数据存储是简单的;它们没有一个类似于SQL的查询语言...
面试被问道：LRU算法的优化手段（一）
程序员阿药的博客
03-11 885
LRU算法的优化手段（一），解决预读失效问题。
LRU缓存淘汰算法优化
u012957549的博客
05-18 3657
上文中提到了LRU 缓存淘汰算法，可以帮助我们更好更合理的去使用缓存。但是它也有一个缺点就是如果有一些不满足“如果数据最近被访问过，那么将来被访问的几率也更高”的规律时，会破坏缓存，导致性能下降。如果缓存的容量比较小，这样还会导致一些热点搜索词的缓存被替换了出去，有可能导致一瞬间大量的请求访问DB 发生缓存击穿。或者 偶然的数据影响会造成命中率较低，比如某个数据即将到达底部即将被淘汰，但由于一次的...
C++一步一步优化LRU算法
a1309525802的博客
01-15 417
c++实现LRU算法LRU单链表代码双向链表+哈希表 LRU 今日无意在头条看到一篇文章,其实吧，LRU也就那么回事 LRU好耳熟的东西,于是乎我就点进去看了看才发现这东西不就是操作系统里将页面置换算法时讲的东西吗? 简单的一张图就能很简单的明白这个算法有多简单,考试要考这种算法感觉就是送分题,当时置换算法最容易理解和最容易计算的就是这个算法,当时考操作系统时贼希望考这种类型的计算题,可是并没有!!! 当时看这个简单理解和计算所以就没怎么太在意他,直到看到那篇文章后才发现其实这种算法在开发中用的特别多,唉
内存优化之缓存中的LRU使用
一个来自吉尔尼斯的博客
03-19 593
lru算法（Least Recently Use），即最近最少使用算法，在Android中比较常用。当内存超过限定大小时，凡是近时间内最少使用的那一个对象，就会从缓存容器中被移除掉。LRU Cache的基础构建用法如下：1.使用LRU Cache时为了能够让Cache知道每个加入的Item的具体大小，我们需要Override下面的方法：2.为了给LRU Cache设置一个比较合理的缓存大小值，我们...
lrucacheleetcode-lru-cache:LRU解决方案
06-29
`lrucache-leetcod-lru-cache`项目可能是针对这些题目的一个开源实现，提供了一个LRU缓存的解决方案。 LRU缓存通常用双向链表结合哈希表来实现。链表用来记录数据项的顺序，哈希表则用于快速查找。当我们访问一个...
LeetCode LRU Cache解决方案：C++编程实践
资源摘要信息:"在本资源中，我们将深入探讨使用C++编写的LeetCode解决方案中的LRU缓存问题。LeetCode是一个流行的在线编程平台，它提供了一系列的算法和数据结构问题供程序员练习和提升编程技能。LRU（最近最少使用...
LeetCode 2020挑战：我的LRU Cache解决方案与思考
- LRU算法的定义和应用场景：在计算机系统中，为了提高数据访问速度，通常会使用缓存（Cache）机制。缓存是一种高速数据存储器，它可以临时存储频繁访问的数据以减少对原始数据源的访问次数，加快数据的读取速度。...
类似LRU定时清除缓存的缓存优化算法详解(缓存淘汰策略)
weixin_42424024的博客
04-21 486
import java.util.HashMap; import java.util.Timer; import java.util.TimerTask; //设计一个类似于LFU 和LRU 的缓存 优化 算法 可以变更的缓存结构 public class Cache { //首先自己定义缓存优化算法的基本的数据结构以及操作缓存的方法 //设计具有双指针的结点 publi...
mysql算法优化_LRU算法及其优化策略——Mysql篇
weixin_29109261的博客
01-28 499
在上一篇文章中，介绍了LRU算法在Redis之中的应用，本篇继续给各位道友介绍在Mysql的InnobDB引擎中，是如何使用LRU算法的。InnoDB缓冲池缓存池简介及内存结构首先来介绍下InnoDB的缓冲池，缓冲池简单来说就是一块内存区域，该区域内缓存着InnoDB访问存储在磁盘的数据和索引信息。缓冲池有两个作用，一是提高了大容量读取操作的效率，二是提高了缓存管理的效率。调配缓存池参数，使得经常...
LRU算法在MySQL/hbase/Caffeine 中的优化
刘本龙的专栏
11-27 1149
在上一篇文章中介绍了LRU的原理及实现，但是实际企业级应用中不会直接使用如此简单的LRU算法。本文看看各个优秀的中间件是如何优化LRU算法的。 mysql对LRU的优化 大家思考一个问题，在我前面讲到的算法实现中，每次访问的数据都会立刻移动到链表的尾端，这样是否是稳定可靠的？答案显然是否定的。实际的应用场景是比较复杂的，大家考虑这样一个场景，你的系统运行了一段时间，缓存都根据LRU算法正常运行，此时，有一个大的查询，数据量比较大，新查询出来的数据根据LRU算法会插入到队尾，此时缓存的数据超出了容量限制，将队
详解基于LRU缓存的LruCache类及其在Android内存优化中的应用
Windy的专栏
07-06 1746
详解基于LRU缓存的LruCache类及其在Android内存优化中的应用
Redis近似LRU算法优化
qq_32506555的博客
11-25 1872
本文和大家分享的主要是redis中，从算法性能及模拟效果提升出发优化近似LRU算法的相关操作，希望通过本文的分享，对大家学习redis 有所帮助。 Redis 3.0 LRU算法优化实现 Redis 3.0中主要做了如下优化： · LRU 时钟的粒度从秒级提升为毫秒级 · 使用新的 API 来获取LRU替换时的采样样本 · 默认的LRU采样样本数从3提升为5 · 使用 evictio
深入探究LRU缓存机制：优化内存利用与提升性能
double222222的博客
03-13 1702
展望未来，随着数据规模的不断增大和计算机系统的不断发展，LRU缓存将继续发挥重要作用。我们期待着更多优秀的算法和技术在LRU缓存领域的应用，以进一步提升系统的性能和效率。最后，本文对LRU缓存的原理、应用和优化进行了总结，并希望读者能够从中获得启发和收获。通过本文的深入探讨，相信读者对LRU缓存有了更加全面和深入的了解。LRU缓存作为一种重要的缓存淘汰策略，不仅在理论上具有重要意义，而且在实际应用中也发挥着重要作用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值