数据结构 - lru&lfu实现（Java）

已于 2022-02-21 22:50:24 修改
阅读量1.1k 收藏 4
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 java 算法
于 2020-12-08 18:31:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/littlewhitevg/article/details/110872018
版权

文章目录

1. LRU 基于哈希表和双向链表的LRU算法实现

缓存看这篇

LinkedHashMap的LRUCache实现

首先看一种简单的实现方式：

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; 
    }
}

其底层就是一个hashmap加双向链表的形式。
那么我们的设计思路是，使用哈希表存储 key，值为链表中的节点，节点中存储值，双向链表来记录节点的顺序，头部为最近访问节点。

LRU算法中有两种基本操作：

get(key)：查询key对应的节点，如果key存在，将节点移动至链表头部。
set(key, value)： 设置key对应的节点的值。如果key不存在，则新建节点，置于链表开头。如果链表长度超标，则将处于尾部的最后一个节点去掉。如果节点存在，更新节点的值，同时将节点置于链表头部。

在这里插入图片描述

首先定义一个双向的链表结构：

public class LinkedList<T> {
    LinkedList prev;
    LinkedList next;

    T value;

    public LinkedList(T t) {
        this.value = t;
    }

    public LinkedList() {
    }
    
}

再在我们的cache体中定义在维护双向链表所必须的api：

public class LRU<K, V> {

    private LinkedList<V> head = new LinkedList<V>();
    private LinkedList<V> tail = new LinkedList<V>();
 	   
}
	//移除双向链表中的结点
    private void remove(LinkedList node) {
        LinkedList prev = node.prev;
        LinkedList next = node.next;
        prev.next = next;
        next.prev = prev;
    }
   //移除最后一个 
   private void removeLast() {
        // 缓存页已满,移除 页尾元素
        //获取 前前一个元素的指针
        LinkedList temp = tail.prev.prev;
        tail.prev = temp;
        temp.next = tail;

    }
	//将结点插入头结点
    private void addFirst(LinkedList node) {

        //把新来的结点插入头结点
        LinkedList temp = head.next;
        head.next = node;
        node.prev = head;
        node.next = temp;
        temp.prev = node;
    }

随后就是整体的实现了，所作的缓存操作基本上就是命中就移除已经命中的缓存，在加入，就算是重复的也会重新创建一个结点进入头部位置：

public class LRU<K, V> {

    private LinkedList<V> head = new LinkedList<V>();
    private LinkedList<V> tail = new LinkedList<V>();

    private int capacity;
    //队列 size
    private int size = 0;
    private HashMap<K, LinkedList<V>> map;


    public LRU(int capacity) {
        this.capacity = capacity;
        this.map = new HashMap<K, LinkedList<V>>(capacity);
        head.next = tail;
        tail.prev = head;
    }

    public static void main(String[] args) {
        LRU<String, String> cache = new LRU<>(4);
        cache.put("123", "123");
        cache.put("125", "125");
        cache.put("124", "124");

        cache.put("123", "123 new");

        cache.put("126", "126");
        cache.put("126", "126 new");
        cache.put("126", "126 new -v2");
        cache.put("125", "125 new");
    }

    public void put(K k, V v) {
        if (size < capacity) {
            //缓存未满
            if (map.containsKey(k)) {
                //重复命中
                remove(map.get(k));
                size--;
            }
            LinkedList<V> node = new LinkedList<>(v);
            map.put(k, node);
            addFirst(node);
            size++;
        } else {
            //缓存已满 未重复命中
            if (!map.containsKey(k)) {
             //将索引从map中移除 存在可优化部分，因为移除需要遍历hash表
             //可将key value放入链表中，损失部分性能来提升运行效率
                removeFromMap((V) tail.prev.value);
                removeLast();
               

            } else {
                //重复命中 将已存在元素移到第一个
                //先删除再添加
                remove(map.get(k));
            }
            LinkedList<V> node = new LinkedList<>(v);
            map.put(k, node);
            addFirst(node);
        }
    //    print();
    }

    private void remove(LinkedList node) {
        LinkedList prev = node.prev;
        LinkedList next = node.next;
        prev.next = next;
        next.prev = prev;
    }


    private void removeFromMap(V v) {
        Iterator<Map.Entry<K, LinkedList<V>>> it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<K, LinkedList<V>> entry = it.next();
            if (entry.getValue().value == v || entry.getValue().equals(v)) {
                it.remove();// 使用迭代器的remove()方法删除元素
            }
        }
    }

    public V get(K k) {
        if (map.containsKey(k)) {
            //如果包含这个key 就将这个key插入到头部
            LinkedList<V> cur = map.get(k);
           remove(cur);
            addFirst(cur);
            print();
            return cur.value;
        } else {
            //不包含 就return null
            print();
            return null;
        }

    }

    public void print() {
        LinkedList next = head;
        while (next != null) {
            if (next.value != null) {
                System.out.println(next.value);
            }
            next = next.next;
        }
        System.out.println("------------------------");
    }

    private void removeLast() {
        // 缓存页已满,移除 页尾元素
        //获取 前前一个元素的指针
        LinkedList temp = tail.prev.prev;
        tail.prev = temp;
        temp.next = tail;

    }

    private void addFirst(LinkedList node) {

        //把新来的结点插入头结点
        LinkedList temp = head.next;
        head.next = node;
        node.prev = head;
        node.next = temp;
        temp.prev = node;
    }
}

测试结果如下：
在这里插入图片描述
页表容量为2时：
在这里插入图片描述
容量为8时：
在这里插入图片描述

2. LFU（LinkedHashSet）

可参考

LFU算法：least frequently used，最近最不经常使用算法。如果一个数据在最近一段时间很少被访问到，那么可以认为在将来它被访问的可能性也很小。因此，当空间满时，最小频率访问的数据最先被淘汰。

set(key,value)：将记录(key,value)插入该结构。当缓存满时，将访问频率最低的数据置换掉。
get(key)：返回key对应的value值。

在这里插入图片描述

class LFUCache {
    Map<Integer, Node> cache;  // 存储缓存的内容
    Map<Integer, LinkedHashSet<Node>> freqMap; // 存储每个频次对应的双向链表
    int size;
    int capacity;
    int min; // 存储当前最小频次

    public LFUCache(int capacity) {
        cache = new HashMap<> (capacity);
        freqMap = new HashMap<>();
        this.capacity = capacity;
    }
    
    public int get(int key) {
        Node node = cache.get(key);
        if (node == null) {
            return -1;
        }
        freqInc(node);
        return node.value;
    }
    
    public void put(int key, int value) {
        if (capacity == 0) {
            return;
        }
        Node node = cache.get(key);
        if (node != null) {
            node.value = value;
            freqInc(node);
        } else {
            if (size == capacity) {
                Node deadNode = removeNode();
                cache.remove(deadNode.key);
                size--;
            }
            Node newNode = new Node(key, value);
            cache.put(key, newNode);
            addNode(newNode);
            size++;     
        }
    }

    void freqInc(Node node) {
        // 从原freq对应的链表里移除, 并更新min
        int freq = node.freq;
        LinkedHashSet<Node> set = freqMap.get(freq);
        set.remove(node);
        if (freq == min && set.size() == 0) { 
            min = freq + 1;
        }
        // 加入新freq对应的链表
        node.freq++;
        LinkedHashSet<Node> newSet = freqMap.get(freq + 1);
        if (newSet == null) {
            newSet = new LinkedHashSet<>();
            freqMap.put(freq + 1, newSet);
        }
        newSet.add(node);
    }

    void addNode(Node node) {
        LinkedHashSet<Node> set = freqMap.get(1);
        if (set == null) {
            set = new LinkedHashSet<>();
            freqMap.put(1, set);
        } 
        set.add(node); 
        min = 1;
    }

    Node removeNode() {
        LinkedHashSet<Node> set = freqMap.get(min);
        Node deadNode = set.iterator().next();
        set.remove(deadNode);
        return deadNode;
    }
}

3. LRU与LFU的区别

贴一个leetcode上大佬的分析：
LRU （Least Recently Used）缓存机制（看时间）
在缓存满的时候，删除缓存里最久未使用的数据，然后再放入新元素；
数据的访问时间很重要，访问时间距离现在越近，就越不容易被删除；
就是喜新厌旧，淘汰在缓存里呆的时间最久的元素。在删除元素的时候，只看「时间」这一个维度。

LFU （Least Frequently Used）缓存机制（看访问次数）
在缓存满的时候，删除缓存里使用次数最少的元素，然后在缓存中放入新元素；
数据的访问次数很重要，访问次数越多，就越不容易被删除；
根据题意，「当存在平局（即两个或更多个键具有相同使用频率）时，最近最少使用的键将被去除」，即在「访问次数」相同的情况下，按照时间顺序，先删除在缓存里时间最久的数据。

核心思想：先考虑访问次数，在访问次数相同的情况下，再考虑缓存的时间。

everyD_struggle
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现LRU，手写双向链表
qq_61886754的博客
04-10 110
else if(size==capacity){ //不存在结点，分类讨论 1.容量已满。if(map.containsKey(key)){ //存在结点，将结点放置在队尾。else{ //2.容量未满，直接添加即可。//下面是移除头结点。int size=0;//双向链表实现，如何使得时间为O(1)?直接取下结点，在头尾插入。//将结点插入到队尾。
数据结构（Java）--查找
雨ゆこ
07-03 1521
由于查找运算的使用频率很高，几乎在任何一个计算机系统软件和应用软件中都会涉及到，所以当问题所涉及的数据量相当大时，查找方法的效率就显得格外重要。在一些实时查询系统中尤其如此。           1、查找条件、查找操作和查找结果 一个数据结构由相同数据类型的多个数据元素所组成，一个数据元素通常由多个数据项组成。关键字是数据元素中用于识别该元素的一个或多个数据项。能够唯一识别
力扣题解 Java语言实现 -- LRU 缓存
天行健 君子以自强不息，地势坤 君子以厚德载物。
08-08 920
LRU是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。也就是说：我没认为最近使用过的数据是 有用的，而那些很久都没有使用过的数据是 无用的，在缓存容量不够的时候，就会删去 无用的数据，这样就可以为新加入的 有用的 数据提供空间。首先需要接收一个 capacity 参数最为缓存的容量，然后实现put(key, val) 方法存入键值对、实现 get(key) 方法获取 key 对应的 val，如果 key 不存在则返回 -1。......
经典的数据结构应用之LRU算法
weixin_44755413的博客
05-20 1271
开篇 接下来的文章我们会介绍有关各种数据结构应用的文章，毕竟数据结构与算法才是算法这个概念的完全体，二者搭配才能解决更多问题。比如今天要说的LRU算法。 LRU算法是一种缓存淘汰策略。 计算机的缓存容量有限，如果缓存满了就要删除一些内容，给新内容腾位置。但问题是，我们应该删除哪些内容呢？我们肯定希望删掉那些没什么用处的缓存，而把有用的数据继续留在缓存中，方便之后继续使用。但是判断有用数据的标准是什么呢？ LRU的全称是Least Recently Used，也就是说我们认为最近使用过的数据应该是有用的，很久
LRU算法和LFU算法
冯同学的博客
06-08 1286
LRU算法和LFU算法
LRU的实现（java）
m0_47113287的博客
03-20 1413
每次访问或者最新插入的节点，我们放在队列的头部。LinkedList的addFirst() 方法添加。那些很久没用的节点就会自动退到 队列的尾部。LinkedList的removeLast() 方法删除。设计思路：用一个双端队列LinkedList （底层是双端链表）来作为 容器。通过观察示例，我们会发现，每次get访问，都需要将 该节点的位置提前。用HashMap来 映射 key 所在的node 节点。LRU：替换 最长时间没有使用的页面。
数据结构(Java)---栈
I_am_fine_的博客
02-27 715
简述栈的概念和基础的操作
java使用hashMap缓存保存数据的方法
09-01
4. **缓存策略**：根据业务需求，可能需要实现LRU（Least Recently Used）或LFU（Least Frequently Used）等缓存淘汰策略，以保持缓存的有效性。 5. **异常处理**：在处理缓存时，需要考虑可能出现的异常情况，如...
Java中常用缓存Cache机制的实现
09-01
在生产环境中，通常需要实现缓存淘汰策略，比如LRU（Least Recently Used）或LFU（Least Frequently Used）。 - **过期策略**：缓存数据可能需要设定过期时间，超时后自动清理。 - **并发控制**：虽然使用了`...
Java面试题-缓存+Redis.pdf
06-12
2. **Redis数据结构及其应用** - **Bitmaps**：Redis的位操作功能，可以高效地存储和查询大量布尔值，常用于用户在线状态跟踪、统计分析等场景。Java客户端可以使用Bitmaps API进行操作，例如`setBit`, `getBit`等...
java学习交流-迅雷笔试题
10-25
其他算法题，如合并两个单向链表、删除URL列表中的重复项、石子问题等，都是经典的计算机科学问题，涉及到数据结构和算法设计。 智力题部分，如一笔画四条直线穿过多点、囚徒帽子问题、硬币游戏等，涉及逻辑推理和...
最热门的Java 算法面试题汇总
04-26
Java算法面试是考察开发者技能的重要环节，涉及到的问题广泛且深入，涵盖了数据结构、算法原理以及实际编程能力。以下是一些热门的Java算法面试题及其详细解释： 1. **双指针问题**：常用于解决数组相关的问题，如...
Java缓存讨论.pdf
03-18
ShiftOne Object Cache提供了一种基础的Java对象缓存机制，实现包括FIFO、LRU和LFU在内的多种缓存策略，允许开发者调整最大元素数量和生存时间。 WhirlyCache是一个内存对象缓存，强调速度和可配置性，旨在通过缓存...
Java面试之Redis基础 1
08-03
Redis主要提供了五种数据结构：String、Hash、List、Set和Sorted Set，这五种数据结构满足了大部分应用开发的需求。在Redis 5.0版本之后，还引入了更多高级特性，如HyperLogLog用于估算不重复元素数量，Geo支持地理...
操作系统，存储管理，java实现。
06-08
缓存管理涉及到缓存替换策略，如LRU（最近最少使用）、LFU（最不经常使用）等。 在这个Java实现的存储管理项目中，很可能包含了上述一些或全部的内存管理机制。使用Java进行实现，可以利用其强大的面向对象特性，...
LRU (最近最少使用) 缓存实现的两种方式
weixin_51935690的博客
03-29 1477
题目如下 LRU最近最少使用，是一种常用的页面置换算法，在容量一定的情况下，删除内存中最近最久未使用的数据。 首先第一种方式：Map 利用在Map当中键值的方式进行存储数据，它的特性就是我们新加入set进去的键值对在其内部是有顺序排列的，及我们set一个键值对它就会去放在后面，这时如果我们容量已满，那么只需要删除掉第一个键值即可（因为常使用（把他移到后方）的和新进入的都会在后方添加进去），然后就实现了一个LRU算法 具体解释都已在代码详细注释 // 第一种方式Map方式 // Map中set加入的键值对是
LRU算法四种实现方式介绍
热门推荐
elricboa的专栏
12-19 20万+
LRU全称是Least Recently Used，即最近最久未使用的意思。 LRU算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。 实现LRU       1.用一个数组来存储数据，给每一个数据项标记一个访问时间戳，每次插入新数据项的时候，先把数组中存
算法学习笔记——数据结构：LRU和LFU（有序字典LinkedHashMap和有序集LinkedHashSet的Python实现）
Insomnia_X的博客
03-24 2093
算法不能脱离数据结构，各种炫酷的算法本质上都是将基本的数据结构进行组合，本文研究链表、二叉树等基本的数据结构能“玩”出什么花样 HashMap：基于哈希表的 Map 接口的实现 HashMap=数组+链表，数组是主体，链表用于解决哈希冲突 不看底层实现，HashMap就是一个(用链表解决哈希冲突的)散列表，在Python中就是字典 哈希链表LinkedHashMap与LRU算法 LRU缓存淘汰算法，全称LeastRecentlyUsed，即认为最近使用的数据是最有用的，在生活中的例子就是手机后台任务：.
Java 实现双链表 造LRU轮子
qq_43399648的博客
06-21 82
LRU(Least Recently Used)是缓存淘汰策略，这个可以联想到早年间，CPU和内存的容量特别小，要想管理好有限的空间，我们就需要执行内存清理。清理什么呢？当然是那些暂时不需要的，LRU就是一种，它负责清理出最近最没有被使用的。其底层是LinkedHashMap, 双向哈希链表，有兴趣可以去读一下源码。
volatile-lru
最新发布
08-05
`volatile-lru` 是 Redis 的一种淘汰策略之一，它用于在内存使用达到配置的最大限制时，选择最近最少使用的带有过期时间的键值对进行删除，以释放内存空间。 具体来说，当 Redis 的内存使用达到配置的最大限制时，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值