LRU(Least Recently Used)缓存算法的实现

开发 前端 算法
LRU就是Least Recently Used,即最近最少使用,是一种常用的页面置换算法,将最近长时间未使用的页面淘汰,其实也很简单,就是要将不受欢迎的页面及时淘汰,不让它占着茅坑不拉shit,浪费资源。

[[349478]]

 LRU就是Least Recently Used,即最近最少使用,是一种常用的页面置换算法,将最近长时间未使用的页面淘汰,其实也很简单,就是要将不受欢迎的页面及时淘汰,不让它占着茅坑不拉shit,浪费资源。

LRU是一种常见的页面置换算法,在计算中,所有的文件操作都要放在内存中进行,然而计算机内存大小是固定的,所以我们不可能把所有的文件都加载到内存,因此我们需要制定一种策略对加入到内存中的文件进项选择。

常见的页面置换算法有如下几种:

  • LRU 最近最久未使用
  • FIFO 先进先出置换算法 类似队列
  • OPT 最佳置换算法 (理想中存在的)
  • NRU Clock置换算法
  • LFU 最少使用置换算法
  • PBA 页面缓冲算法

LRU原理

LRU的设计原理就是,当数据在最近一段时间经常被访问,那么它在以后也会经常被访问。这就意味着,如果经常访问的数据,我们需要然其能够快速命中,而不常访问的数据,我们在容量超出限制内,要将其淘汰。

 

 

 

 

其核心就是利用栈,进行操作,其中主要有两项操作,get和put

get

get时,若栈中有值则将该值的key提到栈顶,没有时则返回null

put

栈未满时,若栈中有要put的key,则更新此key对应的value,并将该键值提到栈顶,若无要put的key,直接入栈

栈满时,若栈中有要put的key,则更新此key对应的value,并将该键值提到栈顶;若栈中没有put的key 时,去掉栈底元素,将put的值入到栈顶

解法:维护一个数组,提供 get 和 put 方法,并且限定 max 数量。

使用时,get 可以标记某个元素是最新使用的,提升它去第一项。put 可以加入某个key-value,但需要判断是否已经到最大限制 max

若未到能直接往数组第一项里插入 若到了最大限制 max,则需要淘汰数据尾端一个元素。

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ ); 
 
cache.put(1, 1); 
cache.put(2, 2); 
cache.get(1);       // 返回  1 
cache.put(3, 3);    // 该操作会使得密钥 2 作废 
cache.get(2);       // 返回 -1 (未找到) 
cache.put(4, 4);    // 该操作会使得密钥 1 作废 
cache.get(1);       // 返回 -1 (未找到) 
cache.get(3);       // 返回  3 
cache.get(4);       // 返回  4 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.

LRU 算法设计

分析上面的操作过程,要让 put 和 get 方法的时间复杂度为 O(1),我们可以总结出 cache 这个数据结构必要的条件:查找快,插入快,删除快,有顺序之分。

因为显然 cache 必须有顺序之分,以区分最近使用的和久未使用的数据;而且我们要在 cache 中查找键是否已存在;如果容量满了要删除最后一个数据;每次访问还要把数据插入到队头。

那么,什么数据结构同时符合上述条件呢?哈希表查找快,但是数据无固定顺序;链表有顺序之分,插入删除快,但是查找慢。所以结合一下,形成一种新的数据结构:哈希链表。

LRU 缓存算法的核心数据结构就是哈希链表,双向链表和哈希表的结合体。这个数据结构长这样:

 

 

 

 

js 实现

  • 具体代码 一般的解法,通过维护一个数组,数组项存放了 key-value 键值对对象,每次需要遍历去寻找 key 值所在的数组下标操作。

已经通过 leetCode 146 的检测。执行用时 : 720 ms。内存消耗 : 58.5 MB。

function LRUCache(capacity) { 
    this.capacity = capacity;   // 最大限制 
    this.cache = []; 
}; 
 
/** 
 * @param {number} key 
 * @return {number} 
 */ 
LRUCache.prototype.get = function (key) { 
    let index = this.cache.findIndex((item) => item.key === key); 
    if (index === -1) { 
        return -1; 
    } 
    // 删除此元素后插入到数组第一项 
    let value = this.cache[index].value; 
    this.cache.splice(index, 1); 
    this.cache.unshift({ 
        key
        value, 
    }); 
    return value; 
}; 
 
/** 
 * @param {number} key 
 * @param {number} value 
 * @return {void} 
 */ 
LRUCache.prototype.put = function (key, value) { 
    let index = this.cache.findIndex((item) => item.key === key); 
    // 想要插入的数据已经存在了,那么直接提升它就可以 
    if (index > -1) { 
        this.cache.splice(index, 1); 
    } else if (this.cache.length >= this.capacity) { 
        // 若已经到达最大限制,先淘汰一个最久没有使用的 
        this.cache.pop(); 
    } 
    this.cache.unshift({ key, value }); 
}; 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.

上面的做法其实有变种,可以通过一个对象来存键值对,一个数组来存放键的顺序。

  • 进阶要求O(1)

时间复杂度 O(1),那就不能数组遍历去查找 key 值。可以用 ES6 的 Map 来解了,因为 Map 既能保持键值对,还能记住插入顺序。

function LRUCache(capacity) { 
    this.cache = new Map(); 
    this.capacity = capacity;  // 最大限制 
}; 
 
LRUCache.prototype.get = function (key) { 
    if (this.cache.has(key)) { 
        // 存在即更新 
        let temp = this.cache.get(key); 
        this.cache.delete(key); 
        this.cache.set(keytemp); 
        return temp
    } 
    return -1; 
}; 
 
LRUCache.prototype.put = function (key, value) { 
    if (this.cache.has(key)) { 
        // 存在即更新(删除后加入) 
        this.cache.delete(key); 
    } else if (this.cache.size >= this.capacity) { 
        // 不存在即加入 
        // 缓存超过最大值,则移除最近没有使用的 
        this.cache.delete(this.cache.keys().next().value); 
    } 
    this.cache.set(key, value); 
}; 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.

 

责任编辑:姜华 来源: JavaScript忍者秘籍
相关推荐

2022-06-17 07:49:14

缓存LRU

2020-02-19 19:18:02

缓存查询速度淘汰算法

2015-07-29 10:31:16

Java缓存算法

2009-07-23 11:11:18

LRU缓存

2023-07-06 12:39:14

RedisLRULFU

2015-07-15 10:19:16

Java代码使用缓存

2020-09-18 10:31:47

LRU算法数组

2024-03-15 07:17:51

MySQLLRU算法缓存池

2021-03-01 18:42:02

缓存LRU算法

2024-10-16 11:28:42

2021-07-15 14:29:06

LRU算法

2021-07-26 21:15:10

LRU缓存MongoDB

2019-12-24 10:32:01

OracleLRU脏块

2020-05-15 17:05:51

Oracle数据库LRU算法

2021-02-22 09:23:55

LRU时间HashMap

2022-05-09 19:59:15

RedisLRU 算法

2021-09-05 18:29:58

Linux内存回收

2021-05-10 07:08:41

数据结构缓存

2012-12-17 14:54:55

算法缓存Java

2017-04-20 09:21:44

pythonLRU算法
点赞
收藏

51CTO技术栈公众号