LRU算法

最新推荐文章于 2024-07-17 20:37:57 发布
最新推荐文章于 2024-07-17 20:37:57 发布
阅读量844 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37469055/article/details/106773671
版权

什么是LRU算法？

  1. LRU是什么？按照英文的直接原义就是Least Recently Used,最近最久未使用法，它是按照一个非常著名的计算机操作系统基础理论得来的：最近使用的页面数据会在未来一段时期内仍然被使用,已经很久没有使用的页面很有可能在未来较长的一段时间内仍然不会被使用。基于这个思想,会存在一种缓存淘汰机制，每次从内存中找到最久未使用的数据然后置换出来，从而存入新的数据！它的主要衡量指标是使用的时间，附加指标是使用的次数。在计算机中大量使用了这个机制，它的合理性在于优先筛选热点数据，所谓热点数据，就是最近最多使用的数据！因为，利用LRU我们可以解决很多实际开发中的问题。

LRU的实现

1：利用双向链表实现

双向链表有一个特点就是它的链表是双路的，我们定义好头节点和尾节点，然后利用先进先出（FIFO），最近被放入的数据会最早被获取。其中主要涉及到添加、访问、修改、删除操作。首先是添加，如果是新元素，直接放在链表头上面，其他的元素顺序往下移动；访问的话，在头节点的可以不用管，如果是在中间位置或者尾巴，就要将数据移动到头节点；修改操作也一样，修改原值之后，再将数据移动到头部；删除的话，直接删除，其他元素顺序移动。

  • 定义基本的链表操作节点
/**
 * @author lizhangyu
 * @date 2020/6/15 21:31
 */
public class Node {

    //键
    Object key;

    //值
    Object value;

    //上一个节点
    Node pre;

    //下一个节点
    Node next;

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

}
  • 链表基本定义
/**
 * @author lizhangyu
 * @date 2020/6/15 21:22
 */
public class LRU<K, V> {

    //当前的大小
    private int currentSize;

    //总容量
    private int capcity;

    //所有的node节点
    private HashMap<K, Node> caches;

    //头节点
    private Node first;

    //尾节点
    private Node last;

    public LRU(int size) {
        currentSize = 0;
        this.capcity = size;
        caches = new HashMap<K, Node>(size);
    }
    
}
  1. 添加元素
  • 添加元素的时候首先判断是不是新的元素，如果是新元素，判断当前的大小是不是大于总容量了，防止超过总链表大小，如果大于的话直接抛弃最后一个节点，然后再以传入的key\value值创建新的节点。对于已经存在的元素，直接覆盖旧值，再将该元素移动到头部，然后保存在map中。
 /**
     * 放入元素
     * @param key
     * @param value
     */
    public void put(K key, V value) {
        Node node = caches.get(key);
        //如果新元素
        if (node == null) {
            //如果超过元素容纳量
            if (caches.size() >= capcity) {
                //移除最后一个节点
                caches.remove(last.key);
                removeLast();
            }
            //创建新节点
            node = new Node(key,value);
        }
        //已经存在的元素覆盖旧值
        node.value = value;
        //把元素移动到首部
        moveToHead(node);
        caches.put(key, node);
    }
  1. 访问元素

通过key值来访问元素，主要的做法就是先判断如果是不存在的，直接返回null。如果存在，把数据移动到首部头节点，然后再返回旧值。

 /**
     * 通过key获取元素
     * @param key
     * @return
     */
    public Object get(K key) {
        Node node = caches.get(key);
        if (node == null) {
            return null;
        }
        //把访问的节点移动到首部
        moveToHead(node);
        return node.value;
    }

如下所示，访问key=3这个节点的时候，需要把3移动到头部，这样能保证整个链表的头节点一定是特点数据(最近使用的数据！)
访问元素的逻辑

  1. 节点删除操作

在根据key删除节点的操作中，我们需要做的是把节点的前一个节点的指针指向当前节点下一个位置，再把当前节点的下一个的节点的上一个指向当前节点的前一个，这么说有点绕，我们来画图来看：

/**
     * 根据key移除节点
     * @param key
     * @return
     */
    public Object remove(K key) {
        Node node = caches.get(key);
        if (node != null) {
            if (node.pre != null) {
                node.pre.next = node.next;
            }
            if (node.next != null) {
                node.next.pre = node.pre;
            }
            if (node == first) {
                first = node.next;
            }
            if (node == last) {
                last = node.pre;
            }
        }
        return caches.remove(key);
    }

假设现在要删除3这个元素，我们第一步要做的就是把3的pre节点4(这里说的都是key值)的下一个指针指向3的下一个节点2，再把3的下一个节点2的上一个指针指向3的上一个节点4，这样3就消失了，从4和2之间断开了，4和2再也不需要3来进行连接，从而实现删除的效果。
　节点删除操作

  1. 移动元素到头节点

首先把当前节点移除,类似于删除的效果(但是没有移除该元素)，然后再将首节点设为当前节点的下一个,再把当前节点设为头节点的前一个节点。当前节点设为首节点。再把首节点的前一个节点设为null，这样就是间接替换了头节点为当前节点。

/**
     * 把当前节点移动到首部
     * @param node
     */
    private void moveToHead(Node node) {
        if (first == node) {
            return;
        }
        if (node.next != null) {
            node.next.pre = node.pre;
        }
        if (node.pre != null) {
            node.pre.next = node.next;
        }
        if (node == last) {
            last = last.pre;
        }
        if (first == null || last == null) {
            first = last = node;
            return;
        }
        node.next = first;
        first.pre = node;
        first = node;
        first.pre = null;
    }

完整代码如下：

import java.util.HashMap;

/**
 * @author lizhangyu
 * @date 2020/6/15 21:22
 */
public class LRU<K, V> {

    //当前的大小
    private int currentSize;

    //总容量
    private int capcity;

    //所有的node节点
    private HashMap<K, Node> caches;

    //头节点
    private Node first;

    //尾节点
    private Node last;

    public LRU(int size) {
        currentSize = 0;
        this.capcity = size;
        caches = new HashMap<K, Node>(size);
    }

    /**
     * 放入元素
     * @param key
     * @param value
     */
    public void put(K key, V value) {
        Node node = caches.get(key);
        //如果新元素
        if (node == null) {
            //如果超过元素容纳量
            if (caches.size() >= capcity) {
                //移除最后一个节点
                caches.remove(last.key);
                removeLast();
            }
            //创建新节点
            node = new Node(key,value);
        }
        //已经存在的元素覆盖旧值
        node.value = value;
        //把元素移动到首部
        moveToHead(node);
        caches.put(key, node);
    }

    /**
     * 通过key获取元素
     * @param key
     * @return
     */
    public Object get(K key) {
        Node node = caches.get(key);
        if (node == null) {
            return null;
        }
        //把访问的节点移动到首部
        moveToHead(node);
        return node.value;
    }

    /**
     * 根据key移除节点
     * @param key
     * @return
     */
    public Object remove(K key) {
        Node node = caches.get(key);
        if (node != null) {
            if (node.pre != null) {
                node.pre.next = node.next;
            }
            if (node.next != null) {
                node.next.pre = node.pre;
            }
            if (node == first) {
                first = node.next;
            }
            if (node == last) {
                last = node.pre;
            }
        }
        return caches.remove(key);
    }

    /**
     * 清除所有节点
     */
    public void clear() {
        first = null;
        last = null;
        caches.clear();
    }

    /**
     * 把当前节点移动到首部
     * @param node
     */
    private void moveToHead(Node node) {
        if (first == node) {
            return;
        }
        if (node.next != null) {
            node.next.pre = node.pre;
        }
        if (node.pre != null) {
            node.pre.next = node.next;
        }
        if (node == last) {
            last = last.pre;
        }
        if (first == null || last == null) {
            first = last = node;
            return;
        }
        node.next = first;
        first.pre = node;
        first = node;
        first.pre = null;
    }

    /**
     * 移除最后一个节点
     */
    private void removeLast() {
        if (last != null) {
            last = last.pre;
            if (last == null) {
                first = null;
            } else {
                last.next = null;
            }
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Node node = first;
        while (node != null) {
            sb.append(String.format("%s:%s ", node.key, node.value));
            node = node.next;
        }
        return sb.toString();
    }


    public static void main(String[] args) {
        LRU<Integer, String> lru = new LRU<Integer, String>(5);
        lru.put(1, "a");
        lru.put(2, "b");
        lru.put(3, "c");
        lru.put(4,"d");
        lru.put(5,"e");
        System.out.println("原始链表为:"+lru.toString());

        lru.get(4);
        System.out.println("获取key为4的元素之后的链表:"+lru.toString());

        lru.put(6,"f");
        System.out.println("新添加一个key为6之后的链表:"+lru.toString());

        lru.remove(3);
        System.out.println("移除key=3的之后的链表:"+lru.toString());
    }
}

输出的结果如下：

原始链表为:5:e 4:d 3:c 2:b 1:a 
获取key为4的元素之后的链表:4:d 5:e 3:c 2:b 1:a 
新添加一个key为6之后的链表:6:f 4:d 5:e 3:c 2:b 
移除key=3的之后的链表:6:f 4:d 5:e 2:b 

Process finished with exit code 0

总结：LRU算法可以让我们把那些久置不用的数据清除掉，避免那些僵尸数据占着内存导致系统因数据量过大而影响性能问题。

脚踏实地，仰望星空
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最近最久未使用（LRU）置换算法
11-25
计算机操作系统 最近最久未使用（LRU）置换算法
LRU——最近最久未使用算法
03-07
LRU置换算法是最近最久未使用置换算法。是根据页面调入内存的使用情况进行决策。
LRU（Least Recently Used,最近最久未使用法）算法
rootkiss的博客
09-28 2130
选择题用的LRU算法推导 Java实现的LRU算法（使用数组而不是链表） 前言： 【小王的困惑】 首先考虑这样的一个业务场景,小王在A公司上班，有一天产品提出了一个需求：“咱们系统的用户啊，每天活跃的就那么多，有太多的僵尸用户，根本不登录，你能不能考虑做一个筛选机制把这些用户刨出去，并且给活跃的用户做一个排名，我们可以设计出一些奖励活动，提升咱们的用户粘性，咱们只需要关注那些活跃的用户就行了“”...
算法 —— LRU算法
最新发布
qq_67693066的博客
07-17 1370
算法 —— LRU算法
【LRU算法】最近最久未使用算法
聪明不喝牛奶的博客
04-20 4695
前言 LRU算法其实就是叫做最近最久未使用算法，经常出现在面试的笔试题目中，更有可能是在面试的过程中让你手撕一下LRU算法。没明白其中的道理的那真的是干熬啊，没办法。所以今天就来总结一下很久之前学的LRU算法。 首先 首先我们要知道我们写这个LRU算法的时候需要用到什么样的数据类型。这里我采用的是双向链表的形式来存储。但是呢，我们知道链表的查找时O(n)的时间复杂度，而删除和插入是O(1)的时间复杂度，这对于我们查找时很不友好的。所以我们得想想能不能将查找元素的时间复杂度降低一些把他也变成O(1)的形式。当
LRU(最近最久未使用算法 c语言)
03-17
操作系统，最近最久未使用算法(c语言版)，有什么不足，bug，请建议，留言。
东南大学操作系统实验——实现LRU算法及其近似算法
06-30
LRU算法是一种常见的虚拟内存管理策略，它根据页面的使用历史来决定替换哪个页面。当内存中的页面被新页面占用时，LRU算法会优先淘汰最近最久未使用的页面。 实验内容包括实现LRU算法的两种不同变体：计数器实现和...
c语言实现的LRU算法
04-04
在C语言中实现LRU算法，需要理解数据结构和算法的基础知识，以及如何在C语言中有效地管理内存。 首先，LRU算法的核心是数据结构的选择。通常使用双向链表来存储数据，因为双向链表允许我们快速地插入和删除元素，...
Java实现LRU算法.zip
11-13
在操作系统中，当内存不足以容纳所有活动页面时，LRU算法会选择最近最久未使用的页面进行淘汰，以腾出空间加载新的页面。 在Java中实现LRU算法，通常会使用数据结构如HashMap或LinkedHashMap来存储页面及其访问信息...
Python实现LRU算法的2种方法
09-21
在Python中，我们可以使用不同的方式来实现LRU算法，主要介绍两种方法：使用`collections.OrderedDict`和使用`dict`与`list`的组合。 ### 方法一：使用`collections.OrderedDict` `collections.OrderedDict` 是...
操作系统之LRU算法（java）（csdn）————程序.pdf
12-05
操作系统之LRU算法（Java） LRU（Least Recently Used，最近最少使用）算法是一种常用的页面置换算法，用于操作系统中管理内存页面。该算法的基本思想是：当进程在 CPU 上运行时，如指令中涉及逻辑地址时，操作系统...
LRU（Least Recently Used, 最近最久未使用）算法。
08-07
实现最近最久未使用（Least Recently Used, LRU）算法。含linux下可执行代码和windows下的工程文件。以及一份实验文档。
​​​​​​​LRU算法（最近最久未使用/最近最少使用算法）
张花生的博客
09-26 2877
根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高” 1、最常见的实现是使用一个链表保存缓存数据 1. 新数据插入到链表头部； 2. 每当缓存命中（即缓存数据被访问），则将数据移到链表头部； 3. 当链表满的时候，将链表尾部的数据丢弃。   【命中率】 当存在热点数据时，LRU的效率很好，但偶发性的、周期性的批量操作会导致LRU命...
最近最久未使用（LRU）算法
牛牛码特的博客
05-24 4538
FIFO算法和OPT算法之间的主要差别是，FIFO算法利用页面进入内存后的时间长短作为置换依据，而OPT算法的依据是将来使用页面的时间。如果以最近的过去作为不久将来的近似，那么就可以把过去最长一段时间里不曾被使用的页面置换掉。它的实质是，当需要置换一页时，选择在之前一段时间里最久没有使用过的页面予以置换。这种算法就称为最久未使用算法（Least Recently Used，LRU）。 LRU算法是与每个页面最后使用的时间有关的。当必须置换一个页面时，LRU算法选择过去一段时间里最久未被使用的页面。 ...
Lru(最近最久未使用)算法
jjegoing的博客
09-22 1163
LRU算法 leetcode 146 最近最久未使用页面置换算法 系统上选择距离当前页面使用时间最长的页面予以淘汰 局部性原理：较长时间未使用的页面，可能不会马上用到 通常使用栈来组织各个驻留页，栈底放最常时间未使用的，栈顶放最近使用的。当加入的元素超过缓存数量，即页框长度时，选择将栈底的元素换出，将新放入的元素放在栈顶. | 页号 |7|0|1|2|0|3|0|4| | 帧1 |7|0|1|2|0|3|0|4| | 帧2 | |7|0|1|2|0|3|0| | 帧3 | | |7|0|1|2
LRU-最近最久未使用算法
彩色天的博客
08-30 341
import java.util.HashMap; import java.util.Map; /** * @author caisebei */ public class LRUCache { private Node head; private Node end; private int limit; private Map<String,Node> hashMap; public LRUCache(int limit) { .
LRU缓存算法(最近最久未使用)
qq_40848299的博客
11-12 247
LRU缓存算法(最近最久未使用) 最近最久未使用策略，优先淘汰最久未使用的数据，也就是上次被访问时间距离现在最久的数据。该策略可以保证内存中的数据都是热点数据，也就是经常被访问的数据，从而保证缓存命中率。 package com.base.cache; import java.util.*; /** * LRU(最近最少使用) * * @author leon * @date 2021年11月08日 19:37 */ public class LRU<K, V> implement
最近最久未使用算法c语言_C语言这么难，为何大家都如飞蛾扑火般学习？现在带你揭秘...
weixin_39743603的博客
12-03 67
很多人对学习C语言感到无从下手，经常问我同一个问题：究竟怎样学习C语言？我是一个程序员，已经开发了很多年的程序，和很多刚刚起步的人一样，学习的第一个计算机语言就是C语言。经过这些年的开发，我深深的体会到C语言对于一个程序设计人员多么的重要，如果不懂C语言，你想写底层程序这几乎听起来很可笑，不懂C语言，你想写出优秀高效的程序，这简直就是天方夜谭。为什么C语言如此重要呢？第一:C语言语法结构很简洁精妙...
最近最久未使用（LRU）置换算法的C++实现
Yuhan2001的CSDN博客
04-06 7620
操作系统的课程实验，最近最久未使用（LRU）置换算法。
基于二叉树的伪LRU算法的更多细节
04-21
非常感谢您的提问。基于二叉树的伪LRU算法是一种内存页面置换算法，它使用二叉树来维护内存页面的访问顺序。具体实现中，每个页面都被看作是一颗二叉树的叶节点，每个内部节点都代表一次访问，其中左节点表示更早访问的页面，右节点表示更晚访问的页面。当需要置换一个页面时，从根节点开始遍历二叉树，根据每个内部节点的左右子节点情况选择向左或向右遍历，并且每经过一个内部节点就将其置于另一侧子树中，以模拟访问顺序。最终到达的叶节点就是即将被置换的页面。这种算法的时间复杂度为O(logn)，其中n为内存页面数。希望这个回答对您有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值