0
  • 聊天消息
  • 系统消息
  • 评论与回复
登录后你可以
  • 下载海量资料
  • 学习在线课程
  • 观看技术视频
  • 写文章/发帖/加入社区
会员中心
创作中心

完善资料让更多小伙伴认识你,还能领取20积分哦,立即完善>

3天内不再提示

一文读懂缓存淘汰算法:LFU 算法

算法与数据结构 来源:labuladong 作者:labuladong 2020-08-25 17:37 次阅读

作者:labuladong

上篇文章算法题就像搭乐高:手把手带你拆解 LRU 算法写了 LRU 缓存淘汰算法的实现方法,本文来写另一个著名的缓存淘汰算法:LFU 算法。

从实现难度上来说,LFU 算法的难度大于 LRU 算法,因为 LRU 算法相当于把数据按照时间排序,这个需求借助链表很自然就能实现,你一直从链表头部加入元素的话,越靠近头部的元素就是新的数据,越靠近尾部的元素就是旧的数据,我们进行缓存淘汰的时候只要简单地将尾部的元素淘汰掉就行了。

而 LFU 算法相当于是淘汰访问频次最低的数据,如果访问频次最低的数据有多条,需要淘汰最旧的数据。把数据按照访问频次进行排序,而且频次还会不断变化,这可不容易实现。

所以说 LFU 算法要复杂很多,labuladong 进字节跳动的时候就被面试官问到了 LFU 算法。

话说回来,这种著名的算法的套路都是固定的,关键是由于逻辑较复杂,不容易写出漂亮且没有 bug 的代码

那么本文 labuladong 就带你拆解 LFU 算法,自顶向下,逐步求精。

一、算法描述

要求你写一个类,接受一个capacity参数,实现get和put方法:

classLFUCache{
//构造容量为capacity的缓存
publicLFUCache(intcapacity){}
//在缓存中查询key
publicintget(intkey){}
//将key和val存入缓存
publicvoidput(intkey,intval){}
}

get(key)方法会去缓存中查询键key,如果key存在,则返回key对应的val,否则返回 -1。

put(key, value)方法插入或修改缓存。如果key已存在,则将它对应的值改为val;如果key不存在,则插入键值对(key, val)。

当缓存达到容量capacity时,则应该在插入新的键值对之前,删除使用频次(后文用freq表示)最低的键值对。如果freq最低的键值对有多个,则删除其中最旧的那个。

//构造一个容量为2的LFU缓存
LFUCachecache=newLFUCache(2);

//插入两对(key,val),对应的freq为1
cache.put(1,10);
cache.put(2,20);

//查询key为1对应的val
//返回10,同时键1对应的freq变为2
cache.get(1);

//容量已满,淘汰freq最小的键2
//插入键值对(3,30),对应的freq为1
cache.put(3,30);

//键2已经被淘汰删除,返回-1
cache.get(2);

二、思路分析

一定先从最简单的开始,根据 LFU 算法的逻辑,我们先列举出算法执行过程中的几个显而易见的事实:

1、调用get(key)方法时,要返回该key对应的val。

2、只要用get或者put方法访问一次某个key,该key的freq就要加一。

3、如果在容量满了的时候进行插入,则需要将freq最小的key删除,如果最小的freq对应多个key,则删除其中最旧的那一个。

好的,我们希望能够在 O(1) 的时间内解决这些需求,可以使用基本数据结构来逐个击破:

1、使用一个HashMap存储key到val的映射,就可以快速计算get(key)。

HashMapkeyToVal;

2、使用一个HashMap存储key到freq的映射,就可以快速操作key对应的freq。

HashMapkeyToFreq;

3、这个需求应该是 LFU 算法的核心,所以我们分开说。

3.1首先,肯定是需要freq到key的映射,用来找到freq最小的key。

3.2、将freq最小的key删除,那你就得快速得到当前所有key最小的freq是多少。想要时间复杂度 O(1) 的话,肯定不能遍历一遍去找,那就用一个变量minFreq来记录当前最小的freq吧。

3.3、可能有多个key拥有相同的freq,所以freq对key是一对多的关系,即一个freq对应一个key的列表。

3.4、希望freq对应的key的列表是存在时序的,便于快速查找并删除最旧的key。

3.5、希望能够快速删除key列表中的任何一个key,因为如果频次为freq的某个key被访问,那么它的频次就会变成freq+1,就应该从freq对应的key列表中删除,加到freq+1对应的key的列表中。

HashMap>freqToKeys;
intminFreq=0;

介绍一下这个LinkedHashSet,它满足我们 3.3,3.4,3.5 这几个要求。你会发现普通的链表LinkedList能够满足 3.3,3.4 这两个要求,但是由于普通链表不能快速访问链表中的某一个节点,所以无法满足 3.5 的要求。

LinkedHashSet顾名思义,是链表和哈希集合的结合体。链表不能快速访问链表节点,但是插入元素具有时序;哈希集合中的元素无序,但是可以对元素进行快速的访问和删除。

那么,它俩结合起来就兼具了哈希集合和链表的特性,既可以在 O(1) 时间内访问或删除其中的元素,又可以保持插入的时序,高效实现 3.5 这个需求。

综上,我们可以写出 LFU 算法的基本数据结构:

classLFUCache{
//key到val的映射,我们后文称为KV表
HashMapkeyToVal;
//key到freq的映射,我们后文称为KF表
HashMapkeyToFreq;
//freq到key列表的映射,我们后文称为FK表
HashMap>freqToKeys;
//记录最小的频次
intminFreq;
//记录LFU缓存的最大容量
intcap;

publicLFUCache(intcapacity){
keyToVal=newHashMap<>();
keyToFreq=newHashMap<>();
freqToKeys=newHashMap<>();
this.cap=capacity;
this.minFreq=0;
}

publicintget(intkey){}

publicvoidput(intkey,intval){}

}

三、代码框架

LFU 的逻辑不难理解,但是写代码实现并不容易,因为你看我们要维护KV表,KF表,FK表三个映射,特别容易出错。对于这种情况,labuladong 教你三个技巧:

1、不要企图上来就实现算法的所有细节,而应该自顶向下,逐步求精,先写清楚主函数的逻辑框架,然后再一步步实现细节。

2、搞清楚映射关系,如果我们更新了某个key对应的freq,那么就要同步修改KF表和FK表,这样才不会出问题。

3、画图,画图,画图,重要的话说三遍,把逻辑比较复杂的部分用流程图画出来,然后根据图来写代码,可以极大减少出错的概率。

下面我们先来实现get(key)方法,逻辑很简单,返回key对应的val,然后增加key对应的freq:

publicintget(intkey){
if(!keyToVal.containsKey(key)){
return-1;
}
//增加key对应的freq
increaseFreq(key);
returnkeyToVal.get(key);
}

增加key对应的freq是 LFU 算法的核心,所以我们干脆直接抽象成一个函数increaseFreq,这样get方法看起来就简洁清晰了对吧。

下面来实现put(key, val)方法,逻辑略微复杂,我们直接画个图来看:

一文读懂缓存淘汰算法:LFU 算法

这图就是随手画的,不是什么正规的程序流程图,但是算法逻辑一目了然,看图可以直接写出put方法的逻辑:

publicvoidput(intkey,intval){
if(this.cap<= 0) return;

    /* 若 key 已存在,修改对应的 val 即可 */
    if (keyToVal.containsKey(key)) {
        keyToVal.put(key, val);
        // key 对应的 freq 加一
        increaseFreq(key);
        return;
    }

    /* key 不存在,需要插入 */
    /* 容量已满的话需要淘汰一个 freq 最小的 key */
    if (this.cap <= keyToVal.size()) {
        removeMinFreqKey();
    }

    /* 插入 key 和 val,对应的 freq 为 1 */
    // 插入 KV 表
    keyToVal.put(key, val);
    // 插入 KF 表
    keyToFreq.put(key, 1);
    // 插入 FK 表
    freqToKeys.putIfAbsent(1, new LinkedHashSet<>());
freqToKeys.get(1).add(key);
//插入新key后最小的freq肯定是1
this.minFreq=1;
}

increaseFreq和removeMinFreqKey方法是 LFU 算法的核心,我们下面来看看怎么借助KV表,KF表,FK表这三个映射巧妙完成这两个函数。

四、LFU 核心逻辑

首先来实现removeMinFreqKey函数:

privatevoidremoveMinFreqKey(){
//freq最小的key列表
LinkedHashSetkeyList=freqToKeys.get(this.minFreq);
//其中最先被插入的那个key就是该被淘汰的key
intdeletedKey=keyList.iterator().next();
/*更新FK表*/
keyList.remove(deletedKey);
if(keyList.isEmpty()){
freqToKeys.remove(this.minFreq);
//问:这里需要更新 minFreq 的值吗?
}
/*更新KV表*/
keyToVal.remove(deletedKey);
/*更新KF表*/
keyToFreq.remove(deletedKey);
}

删除某个键key肯定是要同时修改三个映射表的,借助minFreq参数可以从FK表中找到freq最小的keyList,根据时序,其中第一个元素就是要被淘汰的deletedKey,操作三个映射表删除这个key即可。

但是有个细节问题,如果keyList中只有一个元素,那么删除之后minFreq对应的key列表就为空了,也就是minFreq变量需要被更新。如何计算当前的minFreq是多少呢?

实际上没办法快速计算minFreq,只能线性遍历FK表或者KF表来计算,这样肯定不能保证 O(1) 的时间复杂度。

但是,其实这里没必要更新minFreq变量,因为你想想removeMinFreqKey这个函数是在什么时候调用?在put方法中插入新key时可能调用。而你回头看put的代码,插入新key时一定会把minFreq更新成 1,所以说即便这里minFreq变了,我们也不需要管它。

下面来实现increaseFreq函数:

privatevoidincreaseFreq(intkey){
intfreq=keyToFreq.get(key);
/*更新KF表*/
keyToFreq.put(key,freq+1);
/*更新FK表*/
//将key从freq对应的列表中删除
freqToKeys.get(freq).remove(key);
//将key加入freq+1对应的列表中
freqToKeys.putIfAbsent(freq+1,newLinkedHashSet<>());
freqToKeys.get(freq+1).add(key);
//如果freq对应的列表空了,移除这个freq
if(freqToKeys.get(freq).isEmpty()){
freqToKeys.remove(freq);
//如果这个freq恰好是minFreq,更新minFreq
if(freq==this.minFreq){
this.minFreq++;
}
}
}

更新某个key的freq肯定会涉及FK表和KF表,所以我们分别更新这两个表就行了。

和之前类似,当FK表中freq对应的列表被删空后,需要删除FK表中freq这个映射。如果这个freq恰好是minFreq,说明minFreq变量需要更新。

能不能快速找到当前的minFreq呢?这里是可以的,因为我们刚才把key的freq加了 1 嘛,所以minFreq也加 1 就行了。

至此,经过层层拆解,LFU 算法就完成了。

声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉
  • 算法
    +关注

    关注

    23

    文章

    4607

    浏览量

    92842
  • 数据结构
    +关注

    关注

    3

    文章

    573

    浏览量

    40124

原文标题:算法题就像搭乐高:手把手带你拆解 LFU 算法

文章出处:【微信号:TheAlgorithm,微信公众号:算法与数据结构】欢迎添加关注!文章转载请注明出处。

收藏 人收藏

    评论

    相关推荐

    《CDN 之我见》系列二:原理篇(缓存、安全)

    Hash 运算都得到同个余数),则性能与单链表无异,查找时间复杂度是 O(n)。如果磁盘空间不够了怎么办?使用基于访问热度的内容淘汰算法,例如 FIFO、LRU、LFU、SLRU、
    发表于 06-12 16:59

    深度学习RCNN算法

    目标检测算法图解:看懂RCNN系列算法
    发表于 08-29 09:50

    读懂接口模块的组合应用有哪些?

    读懂接口模块的组合应用有哪些?
    发表于 05-17 07:15

    读懂什么是NEC协议

    读懂什么是NEC协议?
    发表于 10-15 09:22

    星上交换系统输入缓存调度算法

    为改善星上交换系统的性能,该文提出了种新的输入缓存调度算法。该算法基于Crossbar 交换结构,采用了串行调度思想,在兼顾每个端口公平性的基础上调整了输出端口的仲裁策
    发表于 11-17 13:52 10次下载

    HSDPA系统中种感知用户终端缓存状态的QoE保障调度算法

    针对HSDPA系统中现有调度算法无法满足实时业务QoE的缺点,提出种保障实时业务QoE的调度算法。该算法根据用户反馈的信道质量信息和在基站获取到的用户终端
    发表于 01-08 15:24 0次下载

    基于BCH算法的高速缓存纠检错方案研究

    基于BCH算法的高速缓存纠检错方案研究
    发表于 01-07 20:32 0次下载

    读懂数据结构中的算法

    在进步学习数据结构与算法前,我们应该先掌握算法分析的般方法。算法分析主要包括对算法的时空复杂
    的头像 发表于 11-15 15:19 3440次阅读
    <b class='flag-5'>一</b><b class='flag-5'>文</b><b class='flag-5'>读懂</b>数据结构中的<b class='flag-5'>算法</b>

    基于DASH的混合控制码率算法

    针对平滑流(SF)算法在带宽预测时存在的毛刺现象以及仅依靠带宽预测而没有缓存区控制所导致的频繁播放停滞的问题,提出种动态自适应混合控制码率算法。首先,通过使用标准差来代替原SF
    发表于 11-24 16:54 0次下载
    基于DASH的混合控制码率<b class='flag-5'>算法</b>

    基于密策略属性基加密系统访问机制的缓存替换策略

    为提高基于密策略属性基加密( CP-ABE)系统的数据缓存性能,针对CP-ABE加密的数据,提出种有效的缓存替换算法最小属性价值(MAV
    发表于 11-25 11:13 0次下载

    读懂几种常用的安全算法

    摘要算法 • 对称加密算法 • 非对称加密算法 • 数字签名 • 数字证书 数字摘要 实现 • 将任意长度的明文通过单向hash函数摘要成固定长度的串。 Hash(明文)--固定长度的摘要 特点
    发表于 05-30 01:59 1814次阅读
    <b class='flag-5'>一</b><b class='flag-5'>文</b><b class='flag-5'>读懂</b>几种常用的安全<b class='flag-5'>算法</b>

    基于哈希算法和近邻算法缓存数据选择策略

    针对终端用户产生大量相同或相似计算请求的情况,可以通过近似匹配在边缘服务器缓存空间中查找相似数据,选取可复用的计算结果。现有算法大多未考虑数据分布不均的问题,导致计算量和时间开销较大,对此
    发表于 04-19 15:11 3次下载
    基于哈希<b class='flag-5'>算法</b>和近邻<b class='flag-5'>算法</b>的<b class='flag-5'>缓存</b>数据选择策略

    缓存敏感的多属性不等值连接操作算法

    缓存敏感的多属性不等值连接操作算法
    发表于 06-25 16:16 5次下载

    读懂经典双目稠密匹配算法SGM

    最近来看看些双目稠密匹配的算法。说来惭愧,SGM在航测领域是很重要的算法(当然也是最好的双目稠密匹配算法),自己却没有认真读过,只是大
    的头像 发表于 12-15 15:12 1507次阅读

    读懂,什么是BLE?

    读懂,什么是BLE?
    的头像 发表于 11-27 17:11 2280次阅读
    <b class='flag-5'>一</b><b class='flag-5'>文</b><b class='flag-5'>读懂</b>,什么是BLE?