LFU缓存

最新推荐文章于 2024-08-24 07:29:36 发布
最新推荐文章于 2024-08-24 07:29:36 发布
阅读量149 收藏 1
点赞数
文章标签： 数据结构与算法 java
原文链接：http://www.cnblogs.com/weiyinfu/p/8822876.html
版权

https://leetcode-cn.com/problems/lfu-cache/description/

缓存的实现可以采取多种策略，不同策略优点的评估就是“命中率”。好的策略可以实现较高的命中率。常用的策略如：LRU（最近最少使用）、LFU（最不频繁使用）。这两种策略都可以在O（1）时间内实现get和put。关于LRU，在 http://www.cnblogs.com/weiyinfu/p/8546080.html 中已经介绍过。本文主要讲讲LFU的实现。

LFU比LRU复杂，为什么这么说呢？当每个元素只访问一次，则各个元素的使用频率都是1，这是遵循的法则是LRU，即越早被访问的元素越先被删除。LRU的实现可以用Java中的LinkedHashSet实现。

这里复习一下三种Set的区别和联系：

  • HashSet：哈希集，元素无序，读写O（1）
  • TreeSet：元素有序，读写都是O（lgN）
  • LinkedHashSet：双向链表+哈希集，元素有序，元素的顺序为插入的顺序，读写复杂度O（1）

方法一：使用LinkedHashSet实现LRU

第一种方法：三个哈希，使用HashSet实现LRU，因为HashSet中的元素使用的是Integer，可以在HashSet上直接实现LRU；如果HashSet中的元素使用的是Node，则无法直接从HashSet中删除元素。

LFU的关键思路：

  • 对于新插入的元素，它的使用频率是1。如果缓存满了，必须在插入新元素之前移除掉旧元素而不能在插入新元素之后移除最低频使用的元素，因为那样可能会把刚刚插入的新元素删掉。
  • 只需要一个min记录当前使用频次最低的元素，如果新元素来之前队列满了，肯定要删除掉这个min元素，而不是其它使用频次较高的元素。即便这个min元素以后使用频次超过了“倒数第二”，在超过之前一定可以遇到“倒数第二”。
  • LFU需要LRU作为桶，盛放那些使用频次相同的元素。

这段程序的技巧性在于只使用Integer而不使用自定义类型。

import java.util.HashMap;
import java.util.LinkedHashSet;

class LFUCache {
    
    public int capacity;//容量大小
    public HashMap<Integer, Integer> map = new HashMap<>();//存储put进去的key和value
    public HashMap<Integer, Integer> frequent = new HashMap<>();//存储每个key的频率值
    //存储每个频率的相应的key的值的集合，这里用HashSet是因为其是由HashMap底层实现的，可以O(1)时间复杂度查找元素
    //而且linked是有序的，同一频率值越往后越最近访问
    public HashMap<Integer, LinkedHashSet<Integer>> list = new HashMap<>();
    int min = -1;//标记当前频率中的最小值
    
    public LFUCache(int capacity) {
        this.capacity = capacity;
    }
    
    
    public int get(int key) {
        if(!map.containsKey(key)){
            return -1;
        }else{
            int value = map.get(key);//获取元素的value值
            int count = frequent.get(key);
            frequent.put(key, count + 1);
            
            list.get(count).remove(key);//先移除当前key
            
            //更改min的值
            if(count == min && list.get(count).size() == 0)
                min++;
            
            LinkedHashSet<Integer> set = list.containsKey(count + 1) ? list.get(count + 1) : new LinkedHashSet<Integer>();
            set.add(key);
            list.put(count + 1, set);
            
            return value;
        }
        
    }
    
    public void put(int key, int value) {
        if(capacity <= 0){
            return;
        }
        //这一块跟get的逻辑一样
        if(map.containsKey(key)){
            map.put(key, value);
            int count = frequent.get(key);
            frequent.put(key, count + 1);
            
            list.get(count).remove(key);//先移除当前key
            
            //更改min的值
            if (count == min && list.get(count).size() == 0)
                min++;
            
            LinkedHashSet<Integer> set = list.containsKey(count + 1) ? list.get(count + 1) : new LinkedHashSet<Integer>();
            set.add(key);
            list.put(count + 1, set);
        }else{
            if(map.size() >= capacity){
                Integer removeKey = list.get(min).iterator().next();
                list.get(min).remove(removeKey);
                map.remove(removeKey);
                frequent.remove(removeKey);
            }
            map.put(key, value);
            frequent.put(key, 1);
            LinkedHashSet<Integer> set = list.containsKey(1) ? list.get(1) : new LinkedHashSet<Integer>();
            set.add(key);
            list.put(1, set);
            
            min = 1;
        }
        
    }
    
    public static void main(String[] args) {
        LFUCache lfuCache = new LFUCache(2);
        lfuCache.put(2, 1);
        lfuCache.put(3, 2);
        System.out.println(lfuCache.get(3));
        System.out.println(lfuCache.get(2));
        lfuCache.put(4, 3);
        System.out.println(lfuCache.get(2));
        System.out.println(lfuCache.get(3));
        System.out.println(lfuCache.get(4));
    }
}

方法二：使用LinkedHashMap实现LRU

方法其实跟方法一是一样的，方法一使用LinkedHashSet+HashMap实现LRU，实际上完全可以改为LinkedHashMap<Integer,Integer>，这样就能够使用两个组件：frequencyMap和HashMap<frequency,LRU>来实现LFU。

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

class LFUCache {
//key出现的频率为value
HashMap<Integer, Integer> frequency = new HashMap<>();
//频率为key的hashMap为value
HashMap<Integer, LinkedHashMap<Integer, Integer>> a = new HashMap<>();
//时刻记住需要更新哪些全局变量
int min = 0;//最小频率
int capacity;//容器的容量
int nowsize = 0;//当前容器中元素个数

public LFUCache(int capacity) {
    this.capacity = capacity;
}

public String tos(Map<Integer, Integer> ma) {
    StringBuilder builder = new StringBuilder();
    for (int i : ma.keySet()) {
        builder.append(i + ":" + ma.get(i) + " ");
    }
    return builder.toString();
}

public void debug() {
    System.out.println(tos(frequency));
    for (int i : a.keySet()) {
        System.out.println(i + " " + tos(a.get(i)));
    }
    System.out.println("======");
}

public int get(int key) {
    Integer f = frequency.get(key);
    if (f == null) {
        return -1;
    }
    int value = a.get(f).get(key);
    active(key);//激活一下key,使其频率+1
    return value;
}

void active(int key) {
    int f = frequency.get(key);
    frequency.put(key, f + 1);
    LinkedHashMap<Integer, Integer> src = a.get(f), des = a.getOrDefault(f + 1, new LinkedHashMap<>());
    des.put(key, src.remove(key));
    tryRemove(f);
    a.put(f + 1, des);
}

void tryRemove(int frequency) {
    if (a.get(frequency).size() == 0) {
        if (frequency == min) {
            min++;
        }
        a.remove(frequency);
    }
}

void removeLFU() {
    LinkedHashMap<Integer, Integer> ma = a.get(min);
    int removing = ma.keySet().iterator().next();
    ma.remove(removing);//移除掉最早插入的那个结点
    tryRemove(min);
    frequency.remove(removing);
    nowsize--;
}

public void put(int key, int value) {
    if (capacity == 0) return;
    if (frequency.get(key) == null) {
        if (capacity == nowsize) removeLFU();
        nowsize++;
        frequency.put(key, 1);
        LinkedHashMap<Integer, Integer> ff = a.getOrDefault(1, new LinkedHashMap<>());
        ff.put(key, value);
        a.put(1, ff);
        min = 1;//新插入结点之后,最低频率必然为1
    } else {
        active(key);
        a.get(frequency.get(key)).put(key, value);
    }
}

public static void main(String[] args) {
    LFUCache cache = new LFUCache(2);
    String[] op = {"put", "put", "get", "put", "get", "get", "put", "get", "get", "get"};
    int[][] value = {{1, 1}, {2, 2}, {1}, {3, 3}, {2}, {3}, {4, 4}, {1}, {3}, {4}};
    for (int i = 0; i < op.length; i++) {
        System.out.println(op[i] + " " + value[i] + " " + cache.min);
        cache.debug();
        if (op[i].equals("put")) {
            cache.put(value[i][0], value[i][1]);
        } else {
            cache.get(value[i][0]);
        }
    }
}
}

/**
 * Your LFUCache object will be instantiated and called as such:
 * LFUCache obj = new LFUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

方法三：最佳复杂度

在上面的方法中，重要缺点之一就是空间复杂度略微有点高，因为每一个LRU都是使用HashMap实现的，而每一个频率对应一个LRU，这就导致当使用的频率种数很多时，HashMap很多，造成空间巨大浪费。

LFU跟LRU思路是一样的，把最近使用过的东西从左往右排成一排（右面的频率比较高），当使用一个元素之后，把这个元素频率加1，向右面移动几格。应该移动到什么地方呢？这需要快速定位，所以需要快速找到每个频率的最后一个元素，这可以通过建立一个频率到结点的映射来实现。


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

class LFUCache {
//定义双向链表的结点
class Node {
    Node prev, next;
    int key, value;
    int frequency;

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

    @Override
    public String toString() {
        return "(" + key + ":" + value + " " + frequency + ")";
    }
}

//定义双向链表
class LinkedList {
    Node head, tail;

    LinkedList() {
        head = new Node(0, 0);
        tail = new Node(0, 0);
        head.next = tail;
        tail.prev = head;
    }

    //移除双向链表中的结点
    void remove(Node node) {
        Node prev = node.prev;
        Node next = node.next;
        prev.next = next;
        next.prev = prev;
    }

    //在who之后插入newNode
    void insertAfter(Node who, Node newNode) {
        Node next = who.next;
        who.next = newNode;
        newNode.next = next;
        next.prev = newNode;
        newNode.prev = who;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        for (Node i = head.next; i != tail; i = i.next) {
            builder.append(String.format("(%d:%d,%d)->", i.key, i.value, i.frequency));
        }
        return builder.toString();
    }
}

//缓存的容量
int capacity;
//双向链表
LinkedList link = new LinkedList();
//key到Node的映射
Map<Integer, Node> ma = new HashMap<>();
//频率到尾节点的映射
Map<Integer, Node> tail = new HashMap<>();
int nowsize = 0;

public LFUCache(int capacity) {
    this.capacity = capacity;
    link.head.frequency = 0;
    link.tail.frequency = Integer.MAX_VALUE;
    tail.put(link.head.frequency, link.head);
    tail.put(link.tail.frequency, link.tail);
}

String tos(Map<Integer, Node> ma) {
    StringBuilder builder = new StringBuilder();
    for (int i : ma.keySet()) {
        builder.append(i + ":" + ma.get(i) + "  ");
    }
    return builder.toString();
}

void debug() {
    System.out.println(link.toString());
    System.out.println(tos(tail));
    System.out.println(tos(ma));
    System.out.println("========");
}

public int get(int key) {
    Node node = ma.get(key);
    if (node == null) {
        return -1;
    }
    active(node);//命中,激活之
    return node.value;
}

void active(Node node) {
    int f = node.frequency;
    node.frequency++;
    Node prev = node.prev;
    Node master = tail.get(f);//当前频率的老大
    Node masterNext = master.next;//当前老大的下一个
    if (node == master) {
        if (prev.frequency == f) {//我是老大,后继有人
            tail.put(f, prev);
        } else {//我是老大,后继无人
            tail.remove(f);
        }
        if (masterNext.frequency == f + 1) {//下一组频率相邻
            link.remove(node);
            link.insertAfter(tail.get(f + 1), node);
            tail.put(f + 1, node);
        } else {//下一组频率不相邻,链表结构不变
            tail.put(f + 1, node);
        }
    } else {//我不是老大
        if (masterNext.frequency == f + 1) {//下一组频率相邻
            link.remove(node);
            link.insertAfter(tail.get(f + 1), node);
            tail.put(f + 1, node);
        } else {//下一组频率不相邻
            link.remove(node);
            link.insertAfter(master, node);
            tail.put(f + 1, node);
        }
    }
}

//移除掉最近最少使用的结点
void removeLFU() {
    Node node = link.head.next;
    Node next = node.next;
    link.remove(node);
    ma.remove(node.key);
    if (node.frequency != next.frequency) {
        tail.remove(node.frequency);
    }
}

public void put(int key, int value) {
    if (capacity == 0) return;
    Node node = ma.get(key);
    if (node == null) {
        if (nowsize >= capacity) {//容量超了,移除LFU
            removeLFU();
            nowsize--;
        }
        Node newNode = new Node(key, value);
        newNode.frequency = 1;
        Node oneMaster = tail.get(1);//使用频率为1的group
        if (oneMaster == null) {
            link.insertAfter(link.head, newNode);
        } else {
            link.insertAfter(tail.get(1), newNode);
        }
        nowsize++;
        tail.put(1, newNode);
        ma.put(key, newNode);
    } else {
        active(node);
        node.value = value;
    }
}

public static void main(String[] args) {
    LFUCache cache = new LFUCache(3 /* capacity (缓存容量) */);
    String[] ops = {"put", "put", "put", "put", "get"};
    int[][] values = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {4}};
    for (int i = 0; i < ops.length; i++) {
        System.out.println(ops[i] + " " + values[i][0]);
        if (ops[i].equals("put")) {
            cache.put(values[i][0], values[i][1]);
        } else {
            int res = cache.get(values[i][0]);
            System.out.println(res);
        }
        cache.debug();
    }
}
}

/**
 * Your LFUCache object will be instantiated and called as such:
 * LFUCache obj = new LFUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

参考资料

http://www.cnblogs.com/DarrenChan/p/8819996.html

转载于:https://www.cnblogs.com/weiyinfu/p/8822876.html

dejing6575
关注
LeetCode - 460 LFU缓存（Java & JS & Python）
程序员阿甘的博客
12-17 2185
LeetCode - 460 LFU缓存（Java & JS & Python & C）
C/C++ LFU缓存结构设计思路及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-28 7308
根据LFU缓存替换算法，需要记录每个记录的调用次数和最后一次调用时间。可以使用两个哈希表来实现，一个哈希表用于存储记录的键值对，另一个哈希表用于存储记录的调用次数和最后一次调用时间。同时，为了方便删除最少调用的记录，可以使用一个小根堆来保存记录的键值对和调用次数。但是缓存结构中最多放K条记录，如果新的第K+1条记录要加入，就需要根据策略删掉一条记录，然后才能把新记录加入。这个策略为：在缓存结构的K条记录中，哪一个key从进入缓存结构的时刻开始，被调用set或者get的次数最少，就删掉这个key的记录；
460.LFU缓存
zrh_CSDN的博客
11-24 526
设计并实现最不经常使用（LFU）缓存的数据结构。它应该支持以下操作：get 和 put。 get(key) - 如果键存在于缓存中，则获取键的值（总是正数），否则返回 -1。put(key, value) - 如果键不存在，请设置或插入值。当缓存达到其容量时，它应该在插入新项目之前，使最不经常使用的项目无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，最近最少使用的键将被去除。...
LFU Go缓存库实战指南
最新发布
gitblog_00820的博客
08-24 778
LFU Go缓存库实战指南 lfu-goA least frequently used cache for Golang项目地址:https://gitcode.com/gh_mirrors/lf/lfu-go 项目介绍 LFU Go 是一个用Go语言实现的Least Frequently Used（LFU，最不经常使用）缓存算法库，由David Grijalva开发维护。LFU缓存策略基于数据...
460. LFU缓存
风再起时的博客
06-13 207
设计并实现最不经常使用（LFU）缓存的数据结构。它应该支持以下操作：get 和 put。 get(key) - 如果键存在于缓存中，则获取键的值（总是正数），否则返回 -1。 put(key, value) - 如果键不存在，请设置或插入值。当缓存达到其容量时，它应该在插入新项目之前，使最不经常使用的项目无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，最近最少使用的键将被去除。...
LeetCode 460 – LFU缓存
12-21
460. LFU缓存 解法一：哈希表+AVL（C++） 这里的AVL树主要采用C++ STL: :set 时间复杂度： get 时间复杂度 O(log⁡n)O(\log n)O(logn)，put 时间复杂度 O(log⁡n)O(\log n)O(logn)，操作的时间复杂度瓶颈在于平衡...
C++实现的LFU缓存算法
12-25
本算法为 C++ 实现的 LFU 缓存算法，数据结构为 2 个哈希表再加上 N 个双链表，实现了 get() 和 put() 两个操作，且所有操作的平均时间复杂度均可以控制在 O(1) 内。
leetcode和oj-LFU-Cache:LFU缓存
06-30
LFU缓存 介绍 硬件模拟：C++/python实现的LFU缓存模拟 受 leetcode OJ 的启发： 设计和实现最不常用 (LFU) 缓存的数据结构。 它应该支持以下操作：get 和 put。 兼容性 职能： get(key) - 如果键存在于缓存中，则...
【每日一题】LFU 缓存
junxinsiwo的专栏
11-15 744
一个缓存结构需要实现如下功能： 但是缓存最多放 K 条记录，如果新的 K + 1 条记录需要加入，就需要根据策略删掉一条记录，然后才能把新记录加入。 这个策略为：在缓存结构的 K 条记录中，哪一个 key 从进入缓存结构的时刻开始，被调用 set 或者 get 次数最少，就删掉这个key 的记录；如果调用次数最少的 key 有多个，上次调用发送最早的 key 被删除。 这个就是 LFU 缓存替换算法。实现这个结构，K 作为参数。
LFU缓存详解
wolfGuiDao的博客
08-04 2068
LFU缓存详解 文章目录LFU缓存详解一、LFU概念二、分析方法一：哈希表 + 平衡二叉树方法二：双哈希表 一、LFU概念 LRU详解：https://blog.csdn.net/wolfGuiDao/article/details/105862106 LRU 算法相当于把数据按照时间排序，这个需求借助链表很自然就能实现，你一直从链表头部加入元素的话，越靠近头部的元素就是新的数据，越靠近尾部的元素就是旧的数据，我们进行缓存淘汰的时候只要简单地将尾部的元素淘汰掉就行了。 而 LFU 算法相当于是淘
leetcode-460：LFU 缓存
菊头蝙蝠的博客
09-07 245
当缓存达到其容量 capacity 时，则应该在插入新项之前，移除最不经常使用的项。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除 最近最久未使用 的键。当一个键首次插入到缓存中时，它的使用计数器被设置为 1 (由于 put 操作)。对缓存中的键执行 get 或 put 操作，使用计数器的值将会递增。为了确定最不常使用的键，可以为缓存中的每个键维护一个 使用计数器。int get(int key) - 如果键 key 存在于缓存中，则获取键的值，否则返回 -1。
460.LFU 缓存
m0_68014532的博客
09-13 289
请你为 最不经常使用（LFU）缓存算法设计并实现数据结构。 实现 LFUCache 类： LFUCache(int capacity) - 用数据结构的容量capacity 初始化对象 int get(int key)- 如果键key 存在于缓存中，则获取键的值，否则返回 -1 。 void put(int key, int value)- 如果键key 已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量capacity 时，则应该在插入新项之前，移除最不经常使用的项。在此问题
算法----LFU缓存
大魔王
04-06 1229
实现最不经常使用（LFU）缓存算法设计并实现数据结构。 它应该支持以下操作：get和put。 get(key)- 如果键存在于缓存中，则获取键的值（总是正数），否则返回 -1。 put(key, value)- 如果键不存在，请设置或插入值。当缓存达到其容量时，则应该在插入新项之前，使最不经常使用的项无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除 最近 ...
leetcode **460. LFU缓存（暂时放弃研究）（2020.5.4）
Sophia_fez的博客
04-06 198
【题目】460. LFU缓存 请你为 最不经常使用（LFU）缓存算法设计并实现数据结构。它应该支持以下操作：get 和 put。 get(key) - 如果键存在于缓存中，则获取键的值（总是正数），否则返回 -1。 put(key, value) - 如果键不存在，请设置或插入值。当缓存达到其容量时，则应该在插入新项之前，使最不经常使用的项无效。在此问题中，当存在平局（即两个或更多个键具有相同使用...
LFU缓存算法实现：从基础到进阶解析
作者在文章中分享了自己研究LFU算法的过程，以及如何通过不同的数据结构和算法来实现LFU缓存。" LFU缓存是一种常用的缓存淘汰策略，其核心思想是根据元素被访问的频率来决定哪些元素应当优先被淘汰。当缓存满时，最...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值