LRU及LFU算法原理及实现

最新推荐文章于 2025-03-18 17:38:20 发布
最新推荐文章于 2025-03-18 17:38:20 发布
阅读量1.7k 收藏 6
点赞数 2
分类专栏： 算法 数据结构 操作系统 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45466798/article/details/121167152
版权

文章目录

引言

Least Recently Used (LRU)，中文名为最近最少使用，它的设计原则借鉴了时间局部性原理——一个对象如果最近没有被使用，那么将来一段时间内都不会被使用，反之亦成立。具体而言，当空间资源被占用完毕时，如果新增资源加入到空间内部，那么空间内最近未被使用的资源将被调换出去为新资源腾出一个位置。

Least Frequently Used (LFU)，中文名为最不经常使用，它的设计原则是一个对象如果使用频率越低，那么再次被使用的概率也越低。因此，当空间资源被占用完毕时，如果新增资源加入到空间内部，那么空间内使用频率最低的资源将被调换出去为新资源腾出一个位置。

如果第一次听说这两个算法，同学们可能会被他的名字吓懵，但是仔细了解后，发现LRU不过是利用了时间序列的思想进行预判，而LFU则利用了概率的思想进行预判罢了。本文会带着大家了解这两个算法的来源，并给出具体的Java实现。

算法背景

存储器的空间资源十分有限，操作系统为了管理这类资源，会对内存的分配进行优化，一般而言，内存的分配方式主要有四种：

  1. 连续分配方式
  2. 基本分页存储管理方式
  3. 基本分段存储管理方式
  4. 段页式存储管理方式

但这一类管理方式存在一定的局限性，当作业调度时必须一次性将所有页面调入内存，但若内存空间不够时，则作业需等待有足够空间时才能够调度运行。

请求分页管理方式则能够很好地解决这一问题，请求分页管理方式支持虚拟内存，具备页面置换功能，调度作业时仅将一部分页面调入内存，当运行时发生缺页时则采取一定策略将部分页面调出，将需要的页面调入内存。总而言之，请求分页存储管理并不是独立运行的，而是建立在分页式管理的基础之上的一种存储管理方式。

虚拟内存（百度百科）：虚拟内存是计算机系统内存管理的一种技术。它使得应用程序认为它拥有连续的可用的内存（一个连续完整的地址空间），而实际上，它通常是被分隔成多个物理内存碎片，还有部分暂时存储在外部磁盘存储器上，在需要时进行数据交换。

上面提到请求分页管理的特点便是具备页面置换的功能，而页面置换的策略有许多种，LRU和LFU便是其中的两种策略，这也是这两种算法的由来。

LRU代码实现

LRU算法实现难点在于要在O(1)的时间复杂度下完成置换，本文采用 双向链表+哈希表 的方案解决这一问题，这一方案的核心在于：

  1. 将每个节点的key和节点本身以键值对的形式存入哈希表，当空间已被占用完毕且又有新节点加入时则将链表尾部节点删除，此时尾删和头插这两步操作都是O(1)；
  2. 当获取已有节点数据时，则通过key值从HashMap中取出而不是遍历链表，由于HashMap在数据量不大的情况下，get操作可以被认为是O(1)，因此获取已有页面也达到了O(1)的标准。

具体实现如下：

/**
 * LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰
 * LRUCache可以简单修改代码然后cv到LeetCode进行测试 https://leetcode-cn.com/problems/lru-cache-lcci/
 */
public class LRUCache {

    public int capacity;

    public int size;

    static class LRUDoubleLinkedNode {
        String key;
        int val;
        LRUDoubleLinkedNode next;
        LRUDoubleLinkedNode prev;

        LRUDoubleLinkedNode(String key, int val) {
            this.key = key;
            this.val = val;
        }
    }

    public LRUDoubleLinkedNode head;

    public LRUDoubleLinkedNode tail;

    public Map<String, LRUDoubleLinkedNode> cache;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.size = 0;
        head = new LRUDoubleLinkedNode(Constant.HEAD_SENTINEL, 0);
        tail = new LRUDoubleLinkedNode(Constant.TAIL_SENTINEL, 0);
        cache = new HashMap<>();
        head.next = tail;
        tail.prev = head;
    }

    /**
     * 插入页面
     */
    public void put(String key, int val) {
        if (capacity == 0) {
            throw new RuntimeException(Constant.CACHE_CAPACITY_ZERO);
        }
        LRUDoubleLinkedNode node = cache.get(key);
        if (node != null) {
            node.val = val;
            moveToHead(node);
        }else {
            LRUDoubleLinkedNode newNode = new LRUDoubleLinkedNode(key, val);
            cache.put(key, newNode);
            addToHead(newNode);
            size++;
            if (size > capacity) {
                String removeKey = removeLast();
                cache.remove(removeKey);
                size--;
            }
        }
    }

    /**
     * 取出页面
     */
    public int get(String key) {
        if (!cache.containsKey(key)) {
            throw new RuntimeException(Constant.PAGE_IS_NOT_EXIST);
        }
        LRUDoubleLinkedNode node = cache.get(key);
        moveToHead(node);
        return node.val;
    }

    /**
     * 移动页面至头部
     */
    private void moveToHead(LRUDoubleLinkedNode node) {
        remove(node);
        addToHead(node);
    }

    /**
     * 头插法添加页面
     */
    private void addToHead(LRUDoubleLinkedNode node) {
        head.next.prev = node;
        node.next = head.next;
        node.prev = head;
        head.next = node;
    }

    /**
     * 删除页面
     */
    private void remove(LRUDoubleLinkedNode node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    /**
     * 删除尾部页面
     */
    private String removeLast() {
        LRUDoubleLinkedNode node = tail.prev;
        remove(node);
        return node.key;
    }

    /**
     * 测试
     * 因为LRU结构较为复杂，单一测试案例完全无法验证算法的正确性，因此可以前往LeetCode界面进行测试
     */
    public static void main(String[] args) {

        LRUCache lruCache = new LRUCache(1);

        System.out.println("---------------原缓存---------------");
        System.out.println(lruCache.cache.toString());
        System.out.println("\n");

        System.out.println("---------------put测试---------------");
        lruCache.put("1", 2);
        System.out.println(lruCache.cache.toString());
        lruCache.put("1",3);
        System.out.println(lruCache.cache.toString());
        lruCache.put("2", 5);
        System.out.println(lruCache.cache.toString());
        System.out.println("\n");

        System.out.println("---------------get测试---------------");
        int page = lruCache.get("2");
        System.out.println(page);
        lruCache.get("1");

    }
}

LFU代码实现

LFU实现的难点同样在于要在O(1)的时间复杂度下完成置换，但LFU同LRU不同，最近最少使用这一条件使得调出的页面被限定在了空间的尾部，因此查找到这一调出页面的效率是O(1)，但LFU需要知道哪一个页面的历史使用次数最少，这个节点是不固定的。为了解决这一问题，本文采取 双HashMap+双向链表 的方案，这一方案的核心在于：

  1. 第一个HashMap的键值对为 key 和双向链表节点，第二个HashMap的键值对为频数和每个频数对应的双向链表（将所有相同频数的节点组成的链表），此外，再维护一个全局最小频数【即操作数】；
  2. 每次插入一个新节点时，如果空间已满，此时查找最小频数对应的链表，并将该链表的尾部节点取出并删除（O(1)操作），同时维护最小频数【查看最小频数对应的链表是否为空】，最后再删除第一个HashMap中对应的节点，最后将新的节点插入；
  3. 每次要获取一个已有节点时，则更新最小频数，并将对应的链表进行调整，由于操作了一次该节点，因此该节点需要移动至【频数+1】对应的链表头部

综合而言，就是在LRU的基础上将链表节点依照频数进行分组，从而解决了节点不固定的问题。具体实现如下：

/**
 * LFU（least frequently used (LFU) page-replacement algorithm）,即最不经常使用页置换算法.
 * 定义：
 *      LFU根据数据的历史访问频率来淘汰数据，其核心思想是“如果数据过去被访问多次，那么将来被访问的频率也更高”。
 */
public class LFUCache {

    static class LFUDoubleLinkedNode {
        int val;
        int key;
        int freq;
        LFUDoubleLinkedNode prev;
        LFUDoubleLinkedNode next;

        public LFUDoubleLinkedNode() {}

        public LFUDoubleLinkedNode(int key, int val) {
            this.key = key;
            this.val = val;
            this.freq = 1;
        }
    }

    static class LFUDoubleLinkedList {

        public LFUDoubleLinkedNode head;
        public LFUDoubleLinkedNode tail;

        public LFUDoubleLinkedList() {
            this.head = new LFUDoubleLinkedNode();
            this.tail = new LFUDoubleLinkedNode();
            head.next = tail;
            tail.prev = head;
        }

        /**
         * 插入节点
         */
        private void addToHead(LFUDoubleLinkedNode node) {
            head.next.prev = node;
            node.next = head.next;
            node.prev = head;
            head.next = node;
        }

        /**
         * 删除节点
         */
        private void remove(LFUDoubleLinkedNode node) {
            node.prev.next = node.next;
            node.next.prev = node.prev;
        }

        /**
         * 删除尾部节点
         */
        private LFUDoubleLinkedNode removeLast() {
            LFUDoubleLinkedNode node = tail.prev;
            remove(node);
            return node;
        }

    }

    public int capacity; // 最大容量
    public int size; // 当前容量
    public Map<Integer, LFUDoubleLinkedList> freqMap; // 相同频次链表
    public Map<Integer, LFUDoubleLinkedNode> cache; // 节点存储
    public int minFreq; // 当前最小频次

    public LFUCache(int capacity) {
        this.capacity = capacity;
        this.size = 0;
        this.minFreq = 0;
        freqMap = new HashMap<>();
        cache = new HashMap<>();
    }

    /**
     * 获取页面
     */
    public int get(int key) {
        LFUDoubleLinkedNode node = cache.get(key);
        if (node == null) {
            throw new RuntimeException(Constant.PAGE_IS_NOT_EXIST);
        }
        updateFreq(node);
        return node.val;
    }

    /**
     * 插入页面
     */
    public void put(int key, int val) {
        if (capacity == 0) {
            throw new RuntimeException(Constant.CACHE_CAPACITY_ZERO);
        }
        LFUDoubleLinkedNode node = cache.get(key);
        if (node == null) {
            if (size == capacity) {
                LFUDoubleLinkedList minLfuDoubleLinkedList = freqMap.get(minFreq);
                LFUDoubleLinkedNode lfuDoubleLinkedNode = minLfuDoubleLinkedList.removeLast();
                cache.remove(lfuDoubleLinkedNode.key);
                size--;
            }
            node = new LFUDoubleLinkedNode(key, val);
            cache.put(key, node);
            LFUDoubleLinkedList lfuDoubleLinkedList = freqMap.get(node.freq);
            if (lfuDoubleLinkedList == null) {
                lfuDoubleLinkedList = new LFUDoubleLinkedList();
                freqMap.put(node.freq, lfuDoubleLinkedList);
            }
            lfuDoubleLinkedList.addToHead(node);
            size++;
            minFreq = 1;
        }else {
            node.val = val;
            updateFreq(node);
        }
    }

    /**
     * 更新频次
     */
    public void updateFreq(LFUDoubleLinkedNode node) {
        // 删除老频次链表中的节点
        int freq = node.freq;
        LFUDoubleLinkedList lfuDoubleLinkedListOld = freqMap.get(freq);
        lfuDoubleLinkedListOld.remove(node);

        // 更新当前最小频次
        if (freq == minFreq && lfuDoubleLinkedListOld.head.next == lfuDoubleLinkedListOld.tail) {
            minFreq = freq+1;
        }

        // 插入到新频次链表
        node.freq = freq + 1;
        LFUDoubleLinkedList lfuDoubleLinkedListNew = freqMap.get(node.freq);
        if (lfuDoubleLinkedListNew == null) {
            lfuDoubleLinkedListNew = new LFUDoubleLinkedList();
            freqMap.put(node.freq, lfuDoubleLinkedListNew);
        }
        lfuDoubleLinkedListNew.addToHead(node);
    }

    /**
     * 测试,详细测试前往 https://leetcode-cn.com/problems/lfu-cache/submissions/
     */
    public static void main(String[] args) {

        LFUCache lfuCache = new LFUCache(2);
        System.out.println("------------LFU测试------------");
        lfuCache.put(3, 1);
        lfuCache.put(2, 1);
        lfuCache.put(2, 2);
        lfuCache.put(4, 4);
        System.out.println(lfuCache.get(2));

    }
}

结语

LRU和LFU仅仅是页面置换算法中的两种，其实现并不重要，重要的是理解 链表+哈希表 这种数据结构组合使用的思想，因为这两个算法说穿了就是数据结构的举一反三。

Redis中的LRU与LFU算法实现
DxJavascript的博客
09-18 141
LRU（Least Recently Used）和LFU（Least Frequently Used）是Redis中常用的缓存淘汰算法，用于在内存有限的情况下，优化缓存的命中率和性能。本文将深入解析Redis中LRU和LFU算法的实现原理，并附上相应的源代码。LFU算法基于数据被访问的频率来淘汰缓存中的数据，即访问频率最低的数据将被优先淘汰。LRU算法基于最近使用时间来淘汰缓存中的数据，即最近最少使用的数据将被优先淘汰。Redis中的LRU算法通过维护一个有序的链表来实现。
图解缓存淘汰算法 LRU、LFU ｜ 最近最少使用、最不经常使用算法 ｜ go语言实现
m0_74825360的博客
03-02 811
无论是什么系统，在研发的过程中不可避免的会使用到缓存，而缓存一般来说我们不会永久存储，但是缓存的内容是有限的，那么我们如何在有限的内存空间中，尽可能的保留有效的缓存信息呢？那么我们就可以使用 LRU/LFU算法，来维持缓存中的信息的时效性。
LRU和LFU 算法（页面置换算法）
热门推荐
热爱学习和钻研。
02-27 4万+
LRU和LFU的区别 LRU和LFU都是内存管理的页面置换算法。 LRU：最近最少使用(最长时间)淘汰算法（Least Recently Used）。LRU是淘汰最长时间没有被使用的页面。 LFU：最不经常使用(最少次)淘汰算法（Least Frequently Used）。LFU是淘汰一段时间内，使用次数最少的页面。 例子 假设LFU方法的时期T为10分钟，访问如下页面所花的时间正好为10分钟，内存块大小为3。若所需页面顺序依次如下： 2 1 2 1 2 3 4 ----------
LRU算法和LFU算法
冯同学的博客
06-08 3069
LRU算法和LFU算法
LRU 算法和 LFU 算法有什么区别？
最新发布
m0_69529796的博客
03-18 592
LRULFU淘汰标准最近最少用最少被用过关注点时间频率热点变化快适用不适用热点长期稳定不如LFU更优实现复杂度低高Redis 典型策略。
LRU和LFU算法
qq_43325216的博客
09-26 4622
在redis的学习中，了解到了两种缓存清理算法，分别是LRU和LFU，在此针对这两种算法进行学习。
LRU & LFU实现
weixin_45907832的博客
07-21 426
LRU 设计和构建一个“最近最久使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。 它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。 写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删
LRU算法与LFU算法
m0_48847163的博客
01-23 4329
LRU算法 LRU是Least Recently Used的缩写，即最近最少使用算法，是操作系统中页面置换算法的一种，由于内存中存放的页数有限，所以将最近没有使用到的算法会移出内存。 LRU原理： LRU原理如下图所示： 它会将最近访问的节点放在前面，将最近没有访问的节点放在后面。如果缓存空间满了，就会将最后一个节点删掉，并将新的节点添加到首部。 Java实现 对于链式存储的结构，使用到的集合有ArrayList和LinkedList，而ArrayList底层是基于数组的，对元素的移动花费的时间复杂度较高
缓存淘汰策略：LRU、LFU、FIFO 算法原理
Java Punk
02-18 6640
LRU、LFU、FIFO、Two queues（2Q）算法原理
LRU LFU 概念、底层原理及其实现 超详细~
weixin_45532984的博客
10-05 6357
计算机的运行的程序和数据保存在内存中，内存的空间是有限的，所运行的程序可能需要新的数据，而数据不在内存，在磁盘(硬盘)中。CPU 访问的页面在物理内存时，便会产生一个缺页中断，请求操作系统将所缺页调⼊到物理内存。对于要新加入内存的页面，需要一定的算法来确定把哪个页面剔除出去给新的要加进来的页面让位。所以，页面置换算法的功能是，当出现缺页异常，需调入新页面而内存已满时，选择被置换的物理页面，也就是说选择⼀个物理页面换出到磁盘，然后把需要访问的页面换入到物理页。那其算法目标则是，尽可
LFU算法Java实现
MagicianTech的博客
09-11 822
LFU（The Least Frequently Used）即最不经常使用算法。其原理是如果一个数据最近被访问次数不多，那么将来它被使用的可能也更低，因此在内存达到一定阈值时，将最不经常使用的数据淘汰的一种策略算法。
LFU算法实现
远方的少年
11-18 1352
LRU为最近最少使用，LFU为最不经常使用，它们的区别如下 例如1 ->2 -> 1 -> 2 -> 3 -> 4，缓存的容量为3 如果按照LRU，则会淘汰1，因为1访问的事件最远 按照LFU,则3,4访问次数最少，都为1次，4比3访问事件更近，则淘汰3. class LFUCache { Integer capacity; Integer minFrequency; Map<Int...
LeetCode-460. LFU缓存
qq_38236744的博客
04-05 260
设计并实现最不经常使用（LFU）缓存的数据结构。它应该支持以下操作：get 和 put。 get(key) - 如果键存在于缓存中，则获取键的值（总是正数），否则返回 -1。 put(key, value) - 如果键不存在，请设置或插入值。当缓存达到其容量时，它应该在插入新项目之前，使最不经常使用的项目无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，最近最少使用的键将被去除。...
算法-LFU 实现
谈谈1974
11-14 1563
文章目录1. LFU 缓存实现2 . 设计实现 1. LFU 缓存实现 设计实现一个 LFU (最少使用) 缓存机制， 实现 LFUCache 类，leetcode传送门 LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象 int get(int key) - 如果键存在于缓存中，则获取键的值，否则返回 -1 void put(int key, int value) - 如果键已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量时，则应该在插入新
LRU和LFU算法的实现
dandyjiew
07-24 1504
LRU 是一种内存管理算法，也就是最近最少使用，长期不被使用的数据，在未来被用到的几率也不大，因此，当数据所占内存达到一定阈值时，要移除最近最少被使用的数据。可是怎么知道哈希表中哪些key-value最近被访问过，哪些没被访问过，总不能给每一个 Value 加上时间戳，然后遍历整个哈希表。这就涉及到LRU算法的精妙所在，在LRU算法中，使用了一种有趣的数据结构，这汇总数据结构叫做哈希链表。 我们...
【LFU算法】的实现——Java
Mr.蚂蚁的博客
09-23 1509
什么是LFU算法？ LFU算法淘汰的是使用频率最小的 它的名字是：Least Frequently Used algorithm 既然是跟频率有关的，那么就需要用数据结构来存放key-频率。 怎么写？ 首先，列举基本的需求 在调用get(key)时，返回对应的value get 或 put 之后，这个key的频率 +1； 如果在容量满的时候进行put操作，那么就要删除频率最低的（通过频率找到key），如果有多个频率相同，删除最老的那个 以上操作希望是**O(1)**时间复杂度 根据要求
如何实现一个LFU算法
学习学习
11-14 600
Least Frequently Used。也就是最少被使用的方法。核心思想是：如果数据过去被访问多次，那么将来被访问的频率也更高。
【算法】LFU缓存算法的实现
人生何事不浮云
04-10 1211
LFU 算法，即 least frequently used 最近最不常使用，和 LRU 相似，也是一种用于缓存的数据淘汰策略。当内存不足以容纳新的数据时，需要淘汰**最近最不频繁**使用的数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值