LRU与LFU的原理与实现

已于 2022-06-25 10:03:33 修改
阅读量527 收藏
点赞数
分类专栏： 面试相关 文章标签： python 链表 开发语言
于 2022-06-24 17:04:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41744192/article/details/125447906
版权

LRU与LFU的原理与实现python

LRU

LRU(Least Recently Used) 最近最少使用算法，它是根据时间维度来选择将要淘汰的元素，即删除掉最长时间没被访问的元素，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。
一般LRUCache的 get 和 put 必须以 O(1) 的平均时间复杂度运行，必要的条件：查找快，插⼊快，删除快，有顺序 。
首先为了保证数据的读写效率，这就可以采用key-value的哈希结构来帮助我们实现，为了保证数据的顺序可以借助链表来实现，同时为了提高链表结点的插删效率一般使用双向链表，双向链表在一般情况下的插入、删除等操作都要比单链表简单、高效。在这里插入图片描述

LRUCache 类主要特点如下：
capacity以 正整数 作为容量 capacity 初始化 LRU 缓存
get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

#put的流程
1.key已经存在：
	1.在哈希中查询所在的结点，
	2.改变结点原有的value,
	3.更新结点到头部，
2.key不存在：
	1.检查容量是否达到capacity，超出就删除链表尾部结点和对应的哈希，
	2.创建新节点存储key-value,
	3.将结点插入到头部
	
#get操作的流程
1.key不存在，直接返回-1
2.key存在：
	1.在哈希中查询所在的节点
	2.更新结点到链表头部
	3.返回节点的value值，

class lrunode():
    def __init__(self,key=None,val=None,pre=None,next=None):
        self.key = key
        self.val = val
        self.pre = pre
        self.next = next

class LRUCache:
    def __init__(self, capacity: int):
        self.head = lrunode()
        self.tail = lrunode()
        self.head.next = self.tail
        self.tail.pre = self.head
        self.cache = dict()
        self.cache_szie = 0
        self.capacity = capacity

    def move_head(self,node_address):
        if self.head.next == node_address:return
        node_address.pre.next = node_address.next
        node_address.next.pre = node_address.pre
        node_address.next = self.head.next
        node_address.pre = self.head
        self.head.next.pre = node_address
        self.head.next = node_address
        return
   
    def add_head(self,node_address):
        node_address.next = self.head.next
        node_address.pre = self.head
        self.head.next.pre = node_address
        self.head.next = node_address
        return

    def del_tail(self):
        remove_node = self.tail.pre
        remove_node.pre.next = self.tail
        self.tail.pre = remove_node.pre
        return remove_node

    def get(self, key):
        if key not in self.cache:return -1
        node_address = self.cache[key]
        self.move_head(node_address)
        return node_address.val
	
    def put(self, key, value):
        if key in self.cache:
            node_address = self.cache[key]
            node_address.val = value
            self.move_head(node_address)
        else:
	        if self.cache_szie > self.capacity:
	                remove_node = self.del_tail()
	                self.cache.pop(remove_node.key)
	                self.cache_szie -= 1
	                del remove_node
            node_address = lrunode(key,value)
            self.cache[key] = node_address
            self.add_head(node_address)
            self.cache_szie += 1

LFU

参考：leetcode题解
LFU(Least Frequently Used) 最近最不常用算法，它是根据频率维度来选择将要淘汰的元素，即删除访问频率最低的元素。如果两个元素的访问频率相同，则淘汰最久没被访问的元素。
也就是说LFU淘汰的时候会选择两个维度，先比较频率，选择访问频率最小的元素；如果频率相同，则按时间维度淘汰掉最久远的那个元素。
如何实现呢，首先为了保证时间维度，哈希加双向链表的结构肯定是也要采用的，对于频率，可以采用另一个哈希表来存储，为了将这个频率哈希表与链表建立联系，将同一频率的节点放在同一条双向链表上，结点的顺序依旧可以像lru那样表示时间维度，再将链表作为频率哈希表的value值。结构如下：
在这里插入图片描述

get操作的具体逻辑大致是这样：
	如果key不存在则返回-1
	如果key存在，则返回对应的value，同时:
		将元素的访问频率+1
		将元素从访问频率i的链表中移除，放到频率i+1的链表中
		如果频率i的链表为空，则从频率哈希表中移除这个链表
		
put操作
	1.如果key已经存在，
		修改对应结点的value，
		并将访问频率+1
		将元素从访问频率i的链表中移除，放到频率i+1的链表中
		经过上一步，如果频率i的链表变为空，则从频率哈希表中移除这个链表
	2.如果key不存在
		判断缓存是否超过最大容量，
			超出：
				则先删除访问频率最低链表的最后一个元素，
				插入新元素，新元素的访问频率为1，
				如果频率哈希表中不存在对应的链表需要创建
			未超出：
				直接插入新元素，新元素的访问频率为1，
				如果频率哈希表中不存在对应的链表需要创建

class lfunode():
    def __init__(self,key=None,val=None,freq=None,pre=None,next=None):
        self.key = key
        self.val = val
        self.freq = freq
        self.pre = pre
        self.next = next

class link_list():
    def __init__(self):
        self.head = lfunode()
        self.tail = lfunode()
        self.head.next = self.tail
        self.tail.pre = self.head

    def add_head(self,node_address):
        node_address.next = self.head.next
        node_address.pre = self.head
        self.head.next.pre = node_address
        self.head.next = node_address
        return

    def del_linklist_node(self,node_address):
        node_address.pre.next = node_address.next
        node_address.next.pre = node_address.pre
        #del node_address
        return

    def get_last(self):
        return self.tail.pre

    def is_empty(self):
        if self.head.next == self.tail:return True
        return False

class LFUCache:
    def __init__(self, capacity: int):
        self.key_cache = dict()
        self.freq_cache = dict()
        self.min_freq = 0
        self.capacity = capacity

    def set_linklist(self,node_address):
        if node_address.freq not in self.freq_cache:
            self.freq_cache[node_address.freq] = link_list()
        linklist = self.freq_cache[node_address.freq]
        linklist.add_head(node_address)
        return

    def del_node(self,node_address):
        freq = node_address.freq
        linklist = self.freq_cache[freq]
        linklist.del_linklist_node(node_address)
        if linklist.is_empty():
            del self.freq_cache[freq]
        return

    def update_freq_seq(self, node_address, is_new_node=False):
        if is_new_node:
            self.min_freq = 1
            self.set_linklist(node_address)
        else:
            self.del_node(node_address)
            node_address.freq += 1
            self.set_linklist(node_address)
            if self.min_freq not in self.freq_cache:
                self.min_freq += 1
        return
    
    def del_min_freq(self):
        linklist = self.freq_cache[self.min_freq]
        node_address = linklist.get_last()
        linklist.del_linklist_node(node_address)
        del self.key_cache[node_address.key]
        if linklist.is_empty():
            del self.freq_cache[node_address.freq]
        return

    def get(self, key: int) -> int:
        if key not in self.key_cache:return -1
        node_address = self.key_cache[key]
        self.update_freq_seq(node_address)
        return node_address.val

    def put(self, key: int, value: int) -> None:
        if key in self.key_cache:
            node_address = self.key_cache[key]
            node_address.val = value
            self.update_freq_seq(node_address)
        else:
            if self.capacity==0:
                return
            if len(self.key_cache) == self.capacity:
                self.del_min_freq()
            new_node = lfunode(key,value,1)
            self.update_freq_seq(new_node,True)
            self.key_cache[key] = new_node
Sais_Z
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LRU & LFU实现
weixin_45907832的博客
07-21 356
LRU 设计和构建一个“最近最久使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。 它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。 写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删
LRU和LFU算法的实现
dandyjiew
07-24 1423
LRU 是一种内存管理算法，也就是最近最少使用，长期不被使用的数据，在未来被用到的几率也不大，因此，当数据所占内存达到一定阈值时，要移除最近最少被使用的数据。可是怎么知道哈希表中哪些key-value最近被访问过，哪些没被访问过，总不能给每一个 Value 加上时间戳，然后遍历整个哈希表。这就涉及到LRU算法的精妙所在，在LRU算法中，使用了一种有趣的数据结构，这汇总数据结构叫做哈希链表。 我们...
LRU和LFU算法实现原理
one
07-07 816
LRU和LFU算法实现原理 文章目录LRU和LFU算法实现原理前提一、LRU是什么二、LRU算法的思想二、LRU实现一、LFU是什么二、LFU算法的思想二、LFU实现总结 前提 （2021-07-6）午休的时候刷了下技术文章，看到有面试考查 LRU和LFU算法。大概看了下原理于是尝试重现一下。 一、LRU是什么 LRU是一种淘汰算法，全称是Least Recently Used。 二、LRU算法的思想 算法的思想就是：如果一个数据在最近一段时间没有被访问到， 那么在将来它被访问的可能性也很小。 所以
LRU及LFU算法原理及实现
伊文Statistics
11-19 1413
文章目录引言算法背景LRULFU结语 引言 算法背景 LRU LFU 结语
LRU和LFU算法 C++实现
qq_40586164的博客
07-16 680
LRU 【思路】哈希表+双向链表list 使用节点为pair<int,int>的双向链表list，同时用存储对应节点迭代器的哈希表来实现O(1)查询。（用pair<int,int>来代替有key,value两成员的节点Node） 因为从哈希表中删除尾结点时，需要知道尾结点对应的key，所以链表节点必须储存key。 class LRUCache { private: int capacity; list<pair<int,int>> mylist
图形化模拟内存中的FIFO，LRU，LFU存储管理
11-06
2. **页面替换算法的原理**：掌握FIFO、LRU和LFU的基本逻辑，以及它们在实际场景中的优缺点。 3. **Python编程**：熟悉Python语言，能够阅读和理解代码实现。 4. **模拟与可视化**：学习如何用Python进行模拟，以及...
操作系统课设 分页式存储管理（内含OPT，FIFO，LRU，LFU四种算法，用到了线程）
01-13
在这个课设中，学生将深入理解并实践如何实现分页式内存管理，同时涵盖了四种不同的页面替换算法：最优淘汰法（OPT）、先进先出法（FIFO）、最近最久未使用法（LRU）以及最不常用法（LFU）。这些算法都是为了优化...
LRU/LFU页面置换代码/报告
08-30
LRU（Least Recently Used）和LFU（Least ...此外，通过LFU与LRU的比较，可以深入理解不同的页面替换策略对系统性能的影响。这样的实践项目对于学习和理解操作系统原理，特别是内存管理和调度机制，具有很高的价值。
FIFO,LRU,LFU页面置换算法模拟程序.zip
02-07
本资源包含的是一个针对三种常见页面置换算法的模拟程序：FIFO（先进先出）、LRU（最近最少使用）和LFU（最不经常使用）。通过这个程序，用户可以直观地理解这些算法的工作原理和性能差异。 **FIFO（先进先出）页面...
操作系统页面置换算法实现，fifo、lfu、lru、opt，界面由MFC实现
03-28
本项目实现了一个模拟器，用于演示和比较四种不同的页面置换算法：FIFO（先进先出）、LFU（最不常用）、LRU（最近最少使用）以及OPT（最佳页面置换）。界面使用Microsoft Foundation Class (MFC)库来创建，使得用户...
缓存淘汰算法之LRU LFU 和 redis简单的讲解
Dalfalt的博客
04-01 553
Redis（Remote Dictionary Server）是一款基于内存的开源键值对存储数据库，它支持多种数据结构，例如字符串、哈希表、列表、集合和有序集合等。Redis 注重性能，使用 C 语言编写并且所有的操作都发生在内存中，因此它非常快速。Redis以内存作为数据存储介质，所以读写数据的效率极高，远远超过数据库。以设置和获取一个256字节字符串为例，它的读取速度可高达110000次/s，写速度高达81000次/s。举个例子叭！
快速排序、归并排序、LRU和LFU
最新发布
qq_43377917的博客
05-17 245
这四种算法毕竟经典，难度适中，经常面试手撕代码遇到。
数据结构 - lru&lfu实现（Java）
littlewhitevg的博客
12-08 1163
文章目录1. LRU 基于哈希表和双向链表的LRU算法实现2. LFU（LinkedHashSet）LRU与LFU的区别 1. LRU 基于哈希表和双向链表的LRU算法实现 缓存看这篇 LinkedHashMap的LRUCache实现 设计思路是，使用哈希表存储 key，值为链表中的节点，节点中存储值，双向链表来记录节点的顺序，头部为最近访问节点。 LRU算法中有两种基本操作： get(key)：查询key对应的节点，如果key存在，将节点移动至链表头部。 set(key, value)： 设置key对
LRU LFU 概念、底层原理及其实现 超详细~
weixin_45532984的博客
10-05 5978
计算机的运行的程序和数据保存在内存中，内存的空间是有限的，所运行的程序可能需要新的数据，而数据不在内存，在磁盘(硬盘)中。CPU 访问的页面在物理内存时，便会产生一个缺页中断，请求操作系统将所缺页调⼊到物理内存。对于要新加入内存的页面，需要一定的算法来确定把哪个页面剔除出去给新的要加进来的页面让位。所以，页面置换算法的功能是，当出现缺页异常，需调入新页面而内存已满时，选择被置换的物理页面，也就是说选择⼀个物理页面换出到磁盘，然后把需要访问的页面换入到物理页。那其算法目标则是，尽可
算法之LRU和LFU算法
sixingmiyi39473的博客
04-19 2092
在地址映射过程中，若在页面中发现所要访问的页面不在内存中，则产生缺页中断。当发生缺页中断时，如果操作系统内存中没有空闲页面，则操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。而用来选择淘汰哪一页的规则叫做**页面置换算法。**
redis lru和lfu的实现
不说话装高手
06-11 1862
在redis的lru的实现与传统的lru实现不同。 具体实现在evict.c文件中，当redis需要通过释放缓存的key来释放空间时，将会通过ecict.c的freeMemoryIfNeeded()函数来通过设定的算法来清除key以腾出空间。 其中，如果配置的策略是ALL_KEYS才会从所有缓存的key尝试释放，否则只会从存在过期时间的key中进行释放。 struct evictionPo...
常见缓存算法和LRU的c++实现
banyan3646的博客
01-11 1188
对于web开发而言，缓存必不可少，也是提高性能最常用的方式。无论是浏览器缓存(如果是chrome浏览器，可以通过chrome:://cache查看)，还是服务端的缓存(通过memcached或者redis等内存数据库)。缓存不仅可以加速用户的访问，同时也可以降低服务器的负载和压力。那么，了解常见的缓存淘汰算法的策略和原理就显得特别重要。 常见的缓存算法 LRU (Least recen...
LRU 和LFU 算法简单对比
热门推荐
萝卜头
09-21 1万+
why? when? what? 之前面试有问到 LRU 自己没好好准备没答好，现在发现自己竟然把 LRU 理解成了 LFU 呃… 每个算法都有自己的应用场景以及优缺点。各种缓存算法的核心区别在于它的淘汰机制。而这个淘汰机制主要参考这两个维度：最后被访问的时间和最近被访问的频率次数。 LRU(Least Recently Used ):淘汰最后被访问时间最久的元素。 缺点：可能会由于一次冷数...
算法日记——LRU和LFU的O(1)实现
饥渴计科极客杰铿的博客
03-31 1748
LRU和LFU都可以用作缓存置换算法 LRU LRU是Least Recently Used的缩写，即最近最久未使用 主要有两种实现方式 继承LinkedHashMap public class LRUCache&lt;K, V&gt; extends LinkedHashMap&lt;K, V&gt; { private final int MAX_CACHE_SI...
FIFO, LRU, LFU页面置换算法详解与实现
文档详细介绍了三种常见的页面置换算法：FIFO（First-In-First-Out，先进先出）、LRU（Least Recently Used，最近最少使用）和LFU（Least Frequently Used，最不经常使用）。每种算法都有其独特的设计原理和实施方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值