LFU算法Java实现

于 2024-09-11 00:03:47 发布
阅读量467 收藏 7
点赞数 5
分类专栏： 面试题 文章标签： 算法 java python redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MagicianTech/article/details/142111940
版权

Redis内存淘汰策略中会使用到 LFU 算法，以下是简单说明及Java代码实现。

一、前言

LFU（The Least Frequently Used）即最不经常使用算法。其原理是如果一个数据最近被访问次数不多，那么将来它被使用的可能也更低，因此在内存达到一定阈值时，将最不经常使用的数据淘汰的一种策略算法。

二、图解

TODO 图解说明后期有空再补充

三、LFU 算法 Java 实现

3.1 定义节点类

节点Node类中应包含 key（键）、value（值）、cnt（使用频次）和prev（前置节点）、next（后置节点）指针；

import lombok.Getter;
import lombok.Setter;

/**
 * 节点Node
 */
@Getter
@Setter
public class Node {

    /**
     * 节点键key
     */
    private int key;

    /**
     * 节点值value
     */
    private int value;

    /**
     * 使用频次
     */
    private int cnt;

    /**
     * 前置节点
     */
    private Node prev;

    /**
     * 后置节点
     */
    private Node next;

    public Node() {
    }

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

}

注意：代码中 @Getter、@Setter 使用的是 lombok 插件，如果没有安装直接删除这两个注解和对应 import 导入逻辑，再手工给所有属性添加 Getter/Setter 方法即可，后续代码也是不做另外说明；

3.2 双向链表实现

双向链表中定义 dummyHead（虚拟头节点）、dummyTail（虚拟尾节点）两个虚拟头尾节点，避免后续处理中针对头尾节点的特殊处理；再用 length 属性维护链表长度
即
真实头节点：dummyHead.next
真实尾节点：dummyTail.prev

双向链表中定义 add、delete、deleteHead 方法，实现对链表的新增、删除及删除头节点功能（因为我们新增插入是在链表尾部，所以如需淘汰从链表头开始）；

import lombok.Getter;
import lombok.Setter;

/**
 * 双向链表
 * LFU相同使用频次实现使用双向链表存储，头尾节点（head、tail）使用两个默认的虚拟节点，这样避免使用时针对头尾节点的特殊处理
 */
@Getter
@Setter
public class DoubleLinkedList {

    /**
     * 虚拟头节点，实际头节点应为dummyHead.next
     */
    private Node dummyHead;

    /**
     * 虚拟尾节点，实际尾节点应为dummyTail.prev
     */
    private Node dummyTail;

    /**
     * 链表长度
     */
    private int length;

    public DoubleLinkedList() {
        //默认虚拟头、尾节点初始化
        this.dummyHead = new Node();
        this.dummyTail = new Node();
        this.dummyHead.setNext(this.dummyTail);
        this.dummyTail.setPrev(this.dummyHead);
        this.length = 0;
    }

    /**
     * 添加节点
     * 每次添加节点在链表末尾
     * @param node
     */
    public void add(Node node) {
        node.setNext(this.dummyTail);
        node.setPrev(this.dummyTail.getPrev());
        this.dummyTail.getPrev().setNext(node);
        this.dummyTail.setPrev(node);
        this.length++;
    }

    /**
     * 删除节点
     * @param node
     */
    public void delete(Node node) {
        node.getPrev().setNext(node.getNext());
        node.getNext().setPrev(node.getPrev());
        node.setPrev(null);
        node.setNext(null);
        this.length--;
    }

    /**
     * 删除头节点
     */
    public void deleteHead() {
        Node head = this.dummyHead.getNext();
        if (head == null) {
            return;
        }
        this.delete(this.dummyHead.getNext());
    }

}

3.3 LFUCache 类实现

我们使用双向链表 +双哈希表的方式实现LFU。LFUCache 中定义哈希表一 nodeMap（节点Map，key为节点key，值为节点Node）、哈希表二 cntMap（使用频次Map，key为使用频次，值为相同频次节点组成的双向链表，时间最新在链尾）、capacity（容量大小）、length（当前元素数量）属性，且应包含 get、put、getMinCnt（获取最少使用频次） 方法，具体实现见下面代码

import java.util.*;
import java.util.stream.Collectors;

/**
 * LFU算法Java实现，指定容量达到时淘汰使用频次最低数据，同频次则按照LRU删除最早数据
 */
public class LFUCache {

    /**
     * 节点Map
     */
    private Map<Integer, Node> nodeMap;

    /**
     * 使用频次Map，key为使用频次，value为频次相同的双向链表，最新时间放在链表尾部，淘汰从头节点开始
     */
    private Map<Integer, DoubleLinkedList> cntMap;

    /**
     * 容量大小，超过时应淘汰最久未使用数据
     */
    private int capacity;

    /**
     * 当前元素数量
     */
    private int length;

    /**
     * 元素不存在默认为-1
     */
    private static final int NOT_FOUND = -1;

    private static final Integer ONE = 1;

    public LFUCache(int capacity) {
        this.capacity = capacity;
        this.length = 0;
        nodeMap = new HashMap<>();
        cntMap = new HashMap<>();
    }

    /**
     * get获取单个节点值，未找到则返回-1
     * @param key
     * @return
     */
    public int get(int key) {
        if (this.capacity == 0) {
            //容量capacity设置为0直接返回-1
            return NOT_FOUND;
        }
        if (!nodeMap.containsKey(key)) {
            //根据key在哈希表中未找到即不存在返回-1
            return NOT_FOUND;
        }

        //节点存在
        Node node = nodeMap.get(key);
        //根据使用频次cnt获取对应的双向链表，从链表中删除当前元素
        int cnt = node.getCnt();
        cntMap.get(cnt).delete(node);

        //使用频次cnt+1，查询cntMap如链表不存在则新建，将节点插入到链表中（默认插入到链表尾部）
        cnt++;
        DoubleLinkedList linkedList = cntMap.containsKey(cnt) ? cntMap.get(cnt) : new DoubleLinkedList();
        //更新节点使用频次
        node.setCnt(cnt);
        linkedList.add(node);
        cntMap.put(cnt, linkedList);
        return node.getValue();
    }

    /**
     * put新增或更新节点
     * 注意：新增节点时如达到设定容量上限，则应淘汰使用频次最少数据，如频次相同按LFU算法方式处理
     * @param key
     * @param value
     */
    public void put(int key, int value) {
        if (this.capacity == 0) {
            //容量capacity设置为0即认为无法进行put操作，直接返回即可
            return ;
        }

        //键值对存在，即应更新维护键值对新值，且使用频次cnt+1
        if (nodeMap.containsKey(key)) {
            Node node = nodeMap.get(key);

            //根据使用频次cnt获取对应的双向链表，从链表中删除当前元素
            int cnt = node.getCnt();
            cntMap.get(cnt).delete(node);

            //使用频次cnt+1，查询cntMap如链表不存在则新建，将节点插入到链表中（默认插入到链表尾部）
            cnt++;
            DoubleLinkedList linkedList = cntMap.containsKey(cnt) ? cntMap.get(cnt) : new DoubleLinkedList();
            //更新节点使用频次、节点值
            node.setCnt(cnt);
            node.setValue(value);
            linkedList.add(node);
            cntMap.put(cnt, linkedList);
            return ;
        }

        //当容量达到上限需删除使用频次最少数据中的第一个节点
        if (this.length == this.capacity) {
            //最少使用频次
            int minCnt = LFUCache.getMinCnt(cntMap);
            DoubleLinkedList linkedList = cntMap.get(minCnt);
            //哈希表映射中删除对应映射
            nodeMap.remove(linkedList.getDummyHead().getNext().getKey());
            //链表中移除头结点元素
            linkedList.deleteHead();
            if (linkedList.getLength() == 0 && minCnt > 1) {
                //该使用频次链表无节点元素，正常应cntMap中删除该频次节点。但考虑到后续插入新元素频次固定为1，所以此逻辑加一个minCnt大于1才删除的逻辑
                cntMap.remove(minCnt);
            }
        }

        //元素未达到上限前插入动作，则length长度应递增1
        if (this.length < this.capacity) {
            this.length++;
        }

        //哈希表新增映射
        Node node = new Node(key, value);
        nodeMap.put(key, node);

        //新增元素固定频次为1
        DoubleLinkedList linkedList = cntMap.containsKey(ONE) ? cntMap.get(ONE) : new DoubleLinkedList();
        linkedList.add(node);
        cntMap.put(ONE, linkedList);
    }

    @Override
    public String toString() {
        if (this.length == 0) {
            return "LFUCache[]";
        }

        //从头节点开始遍历按顺序打印
        Set<Integer> set = cntMap.keySet();
        List<Integer> list = set.stream().collect(Collectors.toList());
        Collections.sort(list);
        StringBuffer sb = new StringBuffer("LFUCache[");
        for (int i = 0; i < list.size(); i++) {
            Integer k = list.get(i);
            DoubleLinkedList linkedList = cntMap.get(k);
            Node node = linkedList.getDummyHead().getNext();
            while (node != linkedList.getDummyTail()) {
                if (i == list.size() - 1 && node.getNext() == linkedList.getDummyTail()) {
                    //最后一个元素
                    sb.append("{\"key\": ").append(node.getKey()).append(", \"value\": ").append(node.getValue())
                            .append(", \"cnt\": ").append(node.getCnt()).append("}");
                } else {
                    sb.append("{\"key\": ").append(node.getKey()).append(", \"value\": ").append(node.getValue())
                            .append(", \"cnt\": ").append(node.getCnt()).append("}, ");
                }
                node = node.getNext();
            }
        }
        sb.append("]");
        return sb.toString();
    }

    /**
     * 获取最少使用频次
     * @param cntMap 使用频次Map，key为使用频次，value为频次相同的双向链表，时间升序排列
     * @return 最少使用频次
     */
    private static int getMinCnt(Map<Integer, DoubleLinkedList> cntMap) {
        if (cntMap == null || cntMap.size() == 0) {
            throw new IllegalArgumentException("illegal param, cntMap can not be empty.");
        }
        Set<Integer> set = cntMap.keySet();
        List<Integer> list = set.stream().collect(Collectors.toList());
        Collections.sort(list);
        for (int i = 0; i < list.size(); i++) {
            Integer minCnt = list.get(i);
            DoubleLinkedList linkedList = cntMap.get(minCnt);
            if (linkedList == null || linkedList.getLength() == 0) {
                continue;
            }
            //使用频次已升序排列，第一个链表长度大于0的即当前最小频次
            return minCnt;
        }
        //未找到最少使用频次minCnt应抛异常，正常业务场景下cntMap不为空时应必须存在最少使用频次minCnt
        throw new RuntimeException("minCnt is not exist.");
    }
    
}

3.4 测试验证

测试代码如下：

public static void main(String[] args) {
        LFUCache LFUCache = new LFUCache(2);
        LFUCache.put(1, 11);
        LFUCache.put(2, 22);
        System.out.println(LFUCache);
        System.out.println("获取节点1，值为" + LFUCache.get(1));
        System.out.println(LFUCache);

        System.out.println("更新节点2，新值为250");
        LFUCache.put(2, 250);
        System.out.println(LFUCache);
        System.out.println("达到最大容量，插入新值");
        LFUCache.put(6, 66);
        System.out.println(LFUCache);
    }

打印输出如下：

LFUCache[{"key": 1, "value": 11, "cnt": 1}, {"key": 2, "value": 22, "cnt": 1}]
获取节点1，值为11
LFUCache[{"key": 2, "value": 22, "cnt": 1}, {"key": 1, "value": 11, "cnt": 2}]
更新节点2，新值为250
LFUCache[{"key": 1, "value": 11, "cnt": 2}, {"key": 2, "value": 250, "cnt": 2}]
达到最大容量，插入新值
LFUCache[{"key": 6, "value": 66, "cnt": 1}, {"key": 2, "value": 250, "cnt": 2}]
MagicianTech
关注
专栏目录
lfu算法实现java_LFU五种实现方式，从简单到复杂
weixin_34908663的博客
02-23 527
前言最近刷力扣题，对于我这种 0 基础来说，真的是脑壳疼啊。这个月我估计都是中等和困难题，没有简单题了。幸好，力扣上有各种大牛给写题解。看着他们行云流水的代码，真的是羡慕不已。让我印象最深刻的就是人称 “甜姨” 的知心姐姐，还有名叫威哥的大哥。几乎每天他们的题解我都是必看的。甜姨的题解，虽然姿势很帅，但是对于我这种新手来说，感觉不是太友好，因为思路写的太少，不是很详细。所以，每次我看不明白的时候，...
LFU Java实现
qq_35828475的博客
06-03 1789
LFU：least frequency used，当缓存空间不足时，移除使用频率最少的元素 思路：使用三种数据结构， 一个是缓存的元素LFUNode<k,v>, HashMap<k,LFUNode>, TreeMap<Integer,List<LFUNode>> class LFUNode<k,V>{ private k key; private v value; private int count;
java实现LFU
weixin_43831204的博客
10-08 305
public class LFU<k, v> { private final int capcity; private Map<k, v> cache = new HashMap<>(); private Map<k, HitRate> count = new HashMap<>(); public LFU(int capcity) { this.capcity = capcity; } public voi
LFU算法的Java代码实现
BASK2311的博客
04-28 493
算法基础解释，已经会的可以直接跳过哈。LFU是最近不经常使用算法。听到这个名字，就问你迷糊不？还有个类似的叫LRU算法，叫最近最少使用算法。它的代码实现，本人实现了一波，有兴趣可以看下：好了，两者的应用场景基本一致，大多数都是缓存。本质上就是当我缓存的地方满了，现在又要添新的值，需要舍弃哪个旧值？LRU就是舍弃缓存数据中最后一次访问时间最早的数据。（注重时间）LFU即使舍弃访问次数最少的数据中最后一次访问时间最少的数据（注重次数+时间）什么？你还不懂？那我可要举例子了。复制代码。
java实现LFU缓存淘汰算法
西凉的悲伤博客
10-28 1254
import java.util.HashMap; import java.util.LinkedHashSet; public class LFUCache { int cap;//最大缓存的数量 HashMap<String, String> values;//缓存 HashMap<String, Integer> counts;//缓存的访问频次的key-count HashMap<Integer, LinkedHashSet<S
lfu实现 java_LFU算法实现（460. LFU缓存）
weixin_42545503的博客
02-24 367
今天字节客户端三面问了这道题，没做出来。第一，之前没见过lfu，第二，要求O(1)时间，条件苛刻一点。只能说无缘字节。言归正传，LFU算法：least frequently used，最近最不经常使用算法。什么意思呢：对于每个条目，维护其使用次数cnt、最近使用时间time。cache容量为n，即最多存储n个条目。那么当我需要插入新条目并且cache已经满了的时候，需要删除一个之前的条目。删除的策...
Java实现LFU缓存算法
azbh111的博客
06-13 377
Java实现LFU缓存算法
java语言手动实现LFU算法策略及原理分析
nandao158的博客
04-13 1152
今天我们通过java语言手动实现LFU算法策略及原理分析，这是redis缓存策略的一种，因此了解次算法及原很有必要；另外，leetcode 也有次题，介绍是这样的： /** * 请你为 最不经常使用（LFU）缓存算法设计并实现数据结构。 * * 实现 LFUCache 类： * * LFUCache(int capacity) - 用数据结构的容量capacity 初始化对象 * int get(int key)- 如果键key 存在于缓存中，则获取键的值，否则返回 -1 。 * v...
LFU缓存算法及Java实现
fofcn的专栏
02-21 2031
LFU 缓存 算法 Java 实现
缓存淘汰算法 —— LFU-Aging（Java实现）
definite_things的专栏
05-14 5503
Java实现，用HashMap保存key值 : 命中次数与上次命中时间。 import java.util.*; public class LFUAgingMap extends HashMap { private static final int DEFAULT_MAX_SIZE = 3; private int maxSize = DEFAULT_MAX_SIZE;
2021-11-07数据结构LUF代码案例
m0_52568673的博客
11-07 183
LUF代码 也有感到过无能为力，但每时每刻都在等风来，卷起我燃烧的灵魂，吹灭我身上的火焰，带我逃离喧嚣的人间，奔赴自由与浪漫。 ```java class LFUCache { // key 到 val 的映射，我们后文称为 KV 表 HashMap<Integer, Integer> keyToVal; // key 到 freq 的映射，我们后文称为 KF 表 HashMap<Integer, Integer> keyToFreq; //
用Java撸一下LFU简易版本
热门推荐
weixin_43272605的博客
02-19 2万+
最近在别人文章看到一片关于LFU的题目，个人觉得实现可以不同，他用的c，那我用java写一下，毕竟c已经忘的差不多了。 那个题就是让我们来设计一个数据结构，使其能够按照key-value的方式来实现put和get，而且要满足LFU，而且在空间满了之后，又要满足最近最少使用即LRU，且操作时间复杂度要满足O(1) 首先看看什么是LFU LFU(Leatest Frequently Used)即访问频...
LFU cache Java
a33b33C33的专栏
07-24 667
public class LFUCache {     HashMap hashtable = new HashMap();     int column;     PriorityQueue priorityQueue;          public LFUCache(int capacity) {         column = capacity;         KeyVa
Java失效算法与应用（FIFO、LRU、LFU）
最新发布
秃了也弱了
08-03 440
失效算法常见于缓存系统中。因为缓存往往占据大量内存，而内存空间是相对昂贵，且空间有限的，那么针对一部分值，就要依据相应的算法进行失效或移除操作。First In First Out，先来先淘汰。这种算法在每一次新数据插入时，如果队列已满，则将最早插入的数据移除。LRU全称是Least Recently Used，即淘汰最后一次使用时间最久远的数值。FIFO非常的粗暴，不管有没有用到，直接踢掉时间久的元素。而LRU认为，最近频繁使用过的数据，将来也很大程度上会被频繁用到，故而淘汰那些懒惰的数据。
java动态缓存成长小纪（二）——缓存算法的实现：LRU、LFU、FIFO
lcx的专栏
08-14 4031
缓存算法也叫作淘汰算法，主要是为了当JVM空间不足时，用来清理掉缓存的。那么要清理的话，我们先清理掉哪些缓存呢？按照正常人的思维，当然是接下来一段时间内不大可能用到的缓存啦！根据这个思路，我们需要做出一定的判断，判断的方法通常有3个，即LFU、LRU、FIFO。   还有个问题，什么时候进行清理？when? 我觉得一般可以设置一个阈值，标记最小剩余空间，是在插入时候检查JVM剩余空间。或者还
LFU缓存O(1)高效Java实现
编程架构三分天下：分层、分治、分时序。
05-22 373
LFU（Least Frequently Used，最不经常使用），是一种常用的缓存更新/淘汰算法。本文探讨一种get/putget/putget/put时间复杂度均是O(1)O(1)O(1)的高效实现方法。 实现思路 先来实现一个环形双向链表：链表实现了在尾部添加元素（addLast）和头部删除元素（removeFirst）的功能。下文中的两重链表都是通过环形双向链表来做的。 // 环形双向链表实现 public static class LinkedNode { Node head;
一种具有O(1)复杂度的LFU算法实现（java 实现）
学者的博客
03-17 545
当缓存不足时，将优先淘汰访问频次最小的。可以从head开始查找，将找到的第一个从链表中删除即可。即会把a删除，删除后如图。此时聪明的你应该想到如何实现了！下面以一个例子说明其原理。当加入值时，都默认放在这个频次为0的链表中。比如添加a, b, c后。当获取值时，会把它的频次加1，以b为例，即会把b移动到一个新的链表。最近在做一些数据缓存方面的工作。研究了LRU算法和LFU算法。无论是加入、获取、淘汰，操作的复杂度都是O(1)的。
leetcode刷题笔记-460. LFU 缓存（java实现）
成钰的博客
04-16 819
leetcode刷题笔记-460. LFU 缓存（java实现）
java实现LFU算法
07-27
C知道: 要在 Java 中实现 LFU (Least Frequently Used) 算法，您可以按照以下步骤进行操作： 1. 创建一个类来表示缓存项，其中包含键、值和使用计数等属性。 2. 创建一个类来表示 LFU 缓存，其中包含一个哈希表用于快速查找缓存项，以及一个双向链表用于按使用频率排序缓存项。 3. 在 LFU 缓存类中实现以下方法： - `get(key)`：根据键获取缓存项的值，并将该项的使用计数加1，同时更新链表中的位置。 - `put(key, value)`：将键值对添加到缓存中，如果缓存已满，则根据 LFU 算法删除最不常使用的项。 - `evict()`：根据 LFU 算法删除最不常使用的项。 4. 在主程序中创建一个 LFU 缓存对象，并使用 `get` 和 `put` 方法来测试算法的正确性。 这只是一个简单的实现示例，具体的代码实现可能会有所不同，取决于您的需求和设计。希望这个提示能帮到您！如有更多问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值