LRU算法与LFU算法

最新推荐文章于 2024-03-16 13:16:23 发布
最新推荐文章于 2024-03-16 13:16:23 发布
阅读量4.1k 收藏 11
点赞数 3
分类专栏： 计算机笔记 文章标签： 算法 链表 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48847163/article/details/122650495
版权

LRU算法

LRU是Least Recently Used的缩写，即最近最少使用算法，是操作系统中页面置换算法的一种，由于内存中存放的页数有限，所以将最近没有使用到的算法会移出内存。
LRU原理：
LRU原理如下图所示：
在这里插入图片描述
它会将最近访问的节点放在前面，将最近没有访问的节点放在后面。如果缓存空间满了，就会将最后一个节点删掉，并将新的节点添加到首部。

Java实现
对于链式存储的结构，使用到的集合有ArrayList和LinkedList，而ArrayList底层是基于数组的，对元素的移动花费的时间复杂度较高，所以使用LinkedList，基于链表形式的，并且是双向链表，因为要考虑删除节点。而链表的查找时间复杂度也高，但是可以通过使用hash进行快速定位。所以，LRU算法可以通过双向链表和hash来进行实现。

代码部分
手动实现双向链表：

import java.util.HashMap;
import java.util.Map;

public class LRUCache {
    //定义map映射
    private Map<String, Node> map;
    //定义缓存容量
    private int capacity = 8;
    //缓存中当前有一个数据
    private int size = 0;
    //链表的头结点和尾结点
    private Node head, tail;

    //从缓存中读取数据
    public int get(String key) {
        Node node = map.get(key);
        //如果能找到，就将节点移动到链表头部，没有返回-1
        if (node != null) {
            moveToHead(node);
            return node.value;
        }
        return -1;
    }

    //将节点添加到缓存中
    public void put(String key, int value) {
    	if(capacity == 0)   return;
        Node node = map.get(key);
        if (node != null) {
            //如果存在，就将这个点的值进行修改并移到链表头部
            node.value = value;
            moveToHead(node);
            return;
        }

        //如果不存在，先判断空间缓存空间是否足够
        if (size == capacity) {
            map.remove(tail.pre.key);
            deleteNode(tail.pre);
            size -= 1;
        }
        Node newNode = new Node(key, value);
        addToHead(newNode);
        map.put(key, newNode);
        size += 1;
    }

    //将节点移到头结点
    private void moveToHead(Node node) {
        deleteNode(node);
        addToHead(node);
    }

    //将节点添加到头部
    private void addToHead(Node node) {
        node.next = head.next;
        head.next.pre = node;
        node.pre = head;
        head.next = node;
    }

    //删除这个节点
    private void deleteNode(Node node) {
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }

    public LRUCache(int capacity) {
        this.capacity = capacity;
        initLinkedList();
        map = new HashMap<>(capacity);
        size = 0;
    }

    //初始化链表
    private void initLinkedList() {
        head = new Node();
        tail = new Node();
        head.next = tail;
        tail.pre = head;
    }

    public LRUCache() {
        initLinkedList();
        map = new HashMap<>(this.capacity);
    }

    public static class Node {
        public Node pre;
        public Node next;

        public String key;
        public int value;

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

        public Node() {
        }
    }

    public static void main(String[] args) {
        LRUCache cache = new LRUCache(2);
        cache.put("key1", 1);
        cache.put("key2", 2);
        System.out.println(cache.get("key2"));//21
        cache.put("key3", 3);
        System.out.println(cache.get("key1"));//32
    }

}

调用LinkedList API进行实现

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;

public class LRUCache {
    //定义map映射
    private Map<String, Node> map;
    //定义缓存容量
    private int capacity = 8;

    private LinkedList<Node> list = new LinkedList<>();

    //从缓存中读取数据
    public int get(String key) {
        Node node = map.get(key);
        //如果能找到，就将节点移动到链表头部，没有返回-1
        if (node != null) {
            list.remove(node);
            list.addFirst(node);
            return node.value;
        }
        return -1;
    }

    //将节点添加到缓存中
    public void put(String key, int value) {
        if(capacity == 0)   return;
        Node node = map.get(key);
        if (node != null) {
            //如果存在，就将这个点的值进行修改并移到链表头部
            node.value = value;
            list.remove(node);
            list.addFirst(node);
            return;
        }

        //如果不存在，先判断空间缓存空间是否足够
        if (list.size() == capacity) {
            //如果存在，要将map和LinkedList中的删掉
            map.remove(list.getLast().key);
            list.removeLast();
        }
        Node newNode = new Node(key, value);
        map.put(key, newNode);
        list.addFirst(newNode);
    }


    public LRUCache(int capacity) {
        this.capacity = capacity;
        //也是定义map的容量，其实这一步没必要
        map = new HashMap<>(capacity);
    }


    public LRUCache() {
        map = new HashMap<>(this.capacity);
    }

    public static class Node {
        public String key;
        public int value;

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

        public Node() {
        }
    }

    public static void main(String[] args) {
        LRUCache cache = new LRUCache(2);
        cache.put("key1",1);
        cache.put("key2",2);
        System.out.println(cache.get("key2"));  //21
        cache.put("key3",3);
        System.out.println(cache.get("key1"));  //32
    }

}

LFU算法

LFU是 Least Frequently Used 的缩写，即最近最少访问频率，也是操作系统中页面调换算法的一种，将最近使用频率最小，并且很长时间没使用的页面调出内存。

LFU原理
在这里插入图片描述
其中，一个map存储频率和节点的集合之间的关系，即 freq - list，另一个map存储key - node 之间的关系。从key - node 中读到节点，然后去 freq - list 中将节点添加到对应的list集合中

代码部分
由于对每一个频率都要创建一个链表来存储，所以这里直接使用 Java 中的 API 进行实现

package cache;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;

public class LFUCache {

    private Map<String,Node> key_node;
    private Map<Integer, LinkedList<Node>> freq_list;
    private int capacity = 2;

    private int minFreq = 1;


    public int get(String key){
        //如果不包含这个数，返回-1
        if(!key_node.containsKey(key))  return -1;
        Node node = key_node.get(key);
        //获得节点的频率
        int freq = node.freq;
        //当前节点频率加1
        node.freq += 1;
        //从对应的集合中删除节点
        freq_list.get(freq).remove(node);
        //如果删除完节点为0，删除集合
        if(freq_list.get(freq).size() == 0){
            freq_list.remove(freq);
            if(freq == minFreq){
                minFreq += 1;
            }
        }
        LinkedList<Node> list = freq_list.getOrDefault(freq + 1, new LinkedList<Node>());
        list.addFirst(node);
        freq_list.put(freq + 1, list);
        return node.value;
    }


    public void put(String key,int value){
        if(capacity == 0)   return ;
        Node node = key_node.get(key);
        if(node != null){
            //获取当前节点的频率
            int freq = node.freq;
            node.freq += 1;
            node.value = value;
            //从对应的频率节点的集合中删除节点
            freq_list.get(freq).remove(node);
            //如果集合中没有了元素，就将集合删除
            if(freq_list.get(freq).size() == 0){
                freq_list.remove(freq);
                //如果删除的是最小的频次，就让最小的频次加1
                if(freq == minFreq){
                    minFreq += 1;
                }
            }
            //将节点移动到下一个频率的节点集合中
            LinkedList<Node> list = freq_list.getOrDefault(freq + 1, new LinkedList<Node>());
            list.offerFirst(node);
            freq_list.put(freq + 1, list);
            key_node.put(key, node);
        }else {
            Node newNode = new Node(key,value,1);
            //如果缓存容量已经满了，需要将使用频率最低并且长时间没使用的数据删除
            if(key_node.size() == capacity){
                Node lastNode = freq_list.get(minFreq).pollLast();
                key_node.remove(lastNode.key);
                if(freq_list.get(minFreq).size() == 0){
                    freq_list.remove(minFreq);
                }
            }
            //将新的节点添加到集合中
            key_node.put(key,newNode);
            LinkedList<Node> list = freq_list.getOrDefault(1, new LinkedList<Node>());
            list.offerFirst(newNode);
            freq_list.put(1,list);
            minFreq = 1;
        }
    }

    public LFUCache(int capacity) {
        this.capacity = capacity;
        key_node = new HashMap<>();
        freq_list = new HashMap<>();
    }

    public LFUCache() {
        key_node = new HashMap<>();
        freq_list = new HashMap<>();
    }

    public static class Node{
        public String key;
        public int value;
        public int freq;

        public Node() {
        }

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

    public static void main(String[] args) {
        LFUCache cache = new LFUCache(2);
        cache.put("key1",1);    //1
        cache.put("key2",2);    //21
        cache.put("key3",3);    //32
        System.out.println(cache.get("key1"));
        System.out.println(cache.get("key2"));
        System.out.println(cache.get("key3"));
        cache.put("key1",1);    //13
        System.out.println(cache.get("key1"));
        System.out.println(cache.get("key2"));
        System.out.println(cache.get("key3"));
        cache.put("key2",2);    //21
        cache.put("key1",1);    //12
    }
}
lilesien
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis精通系列——LFU算法详述(Least Frequently Used - 最不经常使用)
Java框架、并发编程、分布式、微服务、Redis、HarmonyOS、中间件等技术
09-23 4526
本文已收录于专栏 ❤️《Redis精通系列》❤️ 上千人点赞收藏，全套Redis学习资料，大厂必备技能！ 目录 1、简介 2、实现方式 2.1 LRU实现方式 2.2 LFU实现方式 3、LFU使用 3.1 配置文件开启LFU淘汰算法 1、简介 LRU有一个明显的缺点，它无法正确的表示一个Key的热度，如果一个key从未被访问过，仅仅发生内存淘汰的前一会儿被用户访问了一下，在LRU算法中这会被认为是一个热key。 例如如下图，keyA与keyB同时被set到Redis中，在内存淘汰..
模拟LRU算法
05-19
- **优点**：LRU算法理论上有较好的性能，尤其是在工作集（近期经常访问的页面集合）大小与内存大小相近时。 - **缺点**：实现相对复杂，需要额外的数据结构支持。对于某些访问模式，LRU可能会表现得不如其他算法...
LRU和LFU的区别
学一次的博客
05-05 8622
LRU和LFU都是内存管理的页面置换算法。 LRU，即：最近最少使用淘汰算法（Least Recently Used）。LRU是淘汰最长时间没有被使用的页面。 LRU关键是看数据最后一次被使用到发生替换的时间长短，时间越长，数据就会被置换；
吃透Redis（九）：缓存淘汰篇-LFU算法
吃透Java
09-07 3176
Redis 在 4.0 版本后，还引入了 LFU 算法，也就是最不频繁使用（Least Frequently Used，LFU）算法。LFU 算法在进行数据淘汰时，会把最不频繁访问的数据淘汰掉。而 LRU 算法是把最近最少使用的数据淘汰掉，看起来也是淘汰不频繁访问的数据。那么，LFU 算法和 LRU 算法的区别到底有哪些呢？我们在实际场景中，需要使用 LFU 算法吗？
LFU算法详解
SayBlog
09-22 8564
LFU算法：least frequently used，最近最不经常使用算法 对于每个条目，维护其使用次数 cnt、最近使用时间 time。 cache容量为 n，即最多存储n个条目。 那么当我需要插入新条目并且cache已经满了的时候，需要删除一个之前的条目。删除的策略是：优先删除使用次数cnt最小的那个条目，因为它最近最不经常使用，所以删除它。如果使用次数cnt最小值为min_cnt，这个min_cnt对应的条目有多个，那么在这些条目中删除最近使用时间time最早的那个条目（举个栗子：a资源和b资
LRU与LFU
Sword52888的博客
04-25 1189
LRU（Least Recently Used，最近最少使用）算法和LFU（Least Frequently Used，最近最少使用）算法都是用来作为缓存淘汰机制，保证缓存空间的有效利用。
LRU.rar_LRU_lru算法
09-23
当内存满时，LRU算法会优先淘汰最近最久未使用的页面，以此来为新页面腾出空间。在计算机操作系统中，LRU算法常用于虚拟内存管理，确保频繁访问的数据能够快速存取。 LRU算法的核心思想是：如果一个数据最近被访问...
lru.rar_LRU_lru算法
09-23
在实际应用中，LRU算法的优化和变种也是常见的研究课题，比如LFU（Least Frequently Used）算法，它结合了LRU和访问频率，优先淘汰访问频率低的数据。此外，有些系统会根据数据的热度进行分层缓存，不同层级的缓存...
页面置换算法 FIFO NUR LRU LFU.docx
06-27
页面置换算法 FIFO NUR LRU LFU 页面置换算法是操作系统中虚拟存储管理技术的一种重要组成部分。它的主要任务是将物理内存中的页面换出到辅助存储器中，以腾出空间用于其他进程的使用。常见的页面置换算法有 FIFO、...
页面置换算法 FIFO NUR LRU LFU.pdf
06-27
LFU算法考虑了页面的长期使用频率，更少被访问的页面会被优先替换。 接下来的第四章详细设计，分别对每个算法的实现进行了深入探讨，包括main函数作为主程序入口，FIFO、LRU、NUR（可能是LRU的误写，实际可能是指...
LFU算法的详细介绍与实现
weixin_45746505的博客
07-12 1358
LFU算法的实现
LRU和LFU算法的区别
H_define的博客
08-14 1852
如果使用LFU，应该把3置换为4，虽然3上次使用过，但是1和2都使用过2次，而3只使用过一次，所以替换频率低的3。从名字可以看出，LRU看的是最近一次使用的时间，时间长的被替换，而LFU看的是使用的频率，频率低的被替换。如果使用LRU，应该把1置换为4，因为1已经3次没有使用，而2,3分别为2,1。例如，内存块长度为3，页面顺序为 1 2 1 2 3 4。LRU适合较大的文件，比如游戏中的地图等。LRU和LFU都是页面置换算法。在使用到4时，需要进行页面置换。LFU适合较小的文件。...
图解缓存淘汰算法 LRU、LFU ｜ 最近最少使用、最不经常使用算法 ｜ go语言实现
最新发布
面向生活编程
03-16 3671
无论是什么系统，在研发的过程中不可避免的会使用到缓存，而缓存一般来说我们不会永久存储，但是缓存的内容是有限的，那么我们就可以使用 LRU算法，来维持缓存中的信息的时效性。
缓存淘汰算法LRU和LFU
Johnson_Marteest的博客
06-18 310
前言 LRU算法和LFU算法是属于页面置换的一种算法，或者更通俗的说，就是缓存如何淘汰的一种策略。 我们通常在设计一个系统的时候，由于数据库的读取速度远小于内存的读取速度，所以为了加快读取速度，会将一部分数据放到内存中，称为缓存。 但是内存容量是有限的，当你要缓存的数据超出容量，就得有部分数据删除，这时候哪些数据删除，哪些数据保留，就是LRU算法和LFU算法要干的事。 什么是LRU算法 LRU算法，全称Least recently used，即最近最少使用。LRU算法的思想是如果数据最近被访问过，
java 最少使用(lru)置换算法_缓存淘汰算法LRU和LFU
weixin_39721924的博客
11-23 301
前言LRU算法和LFU算法是属于页面置换的一种算法，或者更通俗的说，就是缓存如何淘汰的一种策略。我们通常在设计一个系统的时候，由于数据库的读取速度远小于内存的读取速度，所以为了加快读取速度，会将一部分数据放到内存中，称为缓存。但是内存容量是有限的，当你要缓存的数据超出容量，就得有部分数据删除，这时候哪些数据删除，哪些数据保留，就是LRU算法和LFU算法要干的事。什么是LRU算法LRU算法，全称Le...
LFU算法(Leetcode)
you are sherlocked by me!
07-06 1768
LFU: 采用LFU算法的最简单方法是为每个加载到缓存的快分配一个计数器.每次引用该块时,计数器将增加1.当缓存达到容量并且有一个新块等待插入时,系统将搜索计数器最低的块并将其从缓存中删除 实现: LFU的每个数据块都有一个引用计数,所有数据块按照引用计数排序,具有相同引用计数的数据块则按照时间排序 新加入数据插入到队列尾部(因为引用计数为1) 队列中的数据被访问后,引用计数增加,队列重新排序 当需要淘汰数据时,将已经排序的列表最后的数据块删除 除了LRU，LFU，还有对于LFU算法的改进，比.
LRU和LFU算法实现原理
one
07-07 812
LRU和LFU算法实现原理 文章目录LRU和LFU算法实现原理前提一、LRU是什么二、LRU算法的思想二、LRU实现一、LFU是什么二、LFU算法的思想二、LFU实现总结 前提 （2021-07-6）午休的时候刷了下技术文章，看到有面试考查 LRU和LFU算法。大概看了下原理于是尝试重现一下。 一、LRU是什么 LRU是一种淘汰算法，全称是Least Recently Used。 二、LRU算法的思想 算法的思想就是：如果一个数据在最近一段时间没有被访问到， 那么在将来它被访问的可能性也很小。 所以
LRU算法跟LFU算法有什么区别
05-04
LRU算法和LFU算法都是缓存置换算法，用于缓存中的数据淘汰。它们的区别在于淘汰的策略不同。 LRU算法（Least Recently Used）是基于时间的置换算法，其核心思想是最近最少使用原则。即当缓存满时，淘汰最久没有使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值