JavaScript如何实现LRU缓存淘汰算法

更新时间：2023年04月26日 10:46:31 作者：雷哥不爱写代码

LRU（Least Recently Used）缓存淘汰算法是一种常见的缓存淘汰策略，它的核心思想是优先淘汰最近最少使用的缓存数据，以保证缓存中的数据始终是最热门的。本文主要介绍了一些关于如何实现LRU缓存淘汰算法的方法，感兴趣的小伙伴可以参考一下

如何实现LRU缓存淘汰算法?

LRU（Least Recently Used）缓存淘汰算法是一种常见的缓存淘汰策略，它的核心思想是优先淘汰最近最少使用的缓存数据，以保证缓存中的数据始终是最热门的。下面是一些关于如何实现LRU缓存淘汰算法的方法：

使用哈希表和双向链表

LRU缓存淘汰算法的核心在于如何快速定位最近最少使用的缓存数据，这可以通过哈希表和双向链表的结合来实现。具体来说，我们可以使用一个哈希表来存储缓存数据的键值对，同时使用一个双向链表来维护缓存数据的访问顺序，每次访问缓存时，我们将访问的数据节点移动到链表头，当缓存满时，淘汰链表尾部的节点即可。

哈希表实现LRU缓存淘汰算法

下面是一个使用哈希表实现LRU缓存淘汰算法的例子，假设我们要实现一个最大容量为3的缓存：

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

class LRUCache<K, V> {
    private int capacity;
    private Map<K, Node<K,V>> cache;
    private Node<K,V> head;
    private Node<K,V> tail;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.cache = new HashMap<>();
        this.head = new Node<>(null, null);
        this.tail = new Node<>(null, null);
        this.head.next = this.tail;
        this.tail.prev = this.head;
    }

    public V get(K key) {
        if (!cache.containsKey(key)) {
            return null;
        }
        Node<K,V> node = cache.get(key);
        remove(node);
        addFirst(node);
        return node.value;
    }

    public void put(K key, V value) {
        if (cache.containsKey(key)) {
            Node<K,V> node = cache.get(key);
            node.value = value;
            remove(node);
            addFirst(node);
        } else {
            if (cache.size() == capacity) {
                Node<K,V> node = removeLast();
                cache.remove(node.key);
            }
            Node<K,V> node = new Node<>(key, value);
            cache.put(key, node);
            addFirst(node);
        }
    }

    private void remove(Node<K,V> node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private void addFirst(Node<K,V> node) {
        node.next = head.next;
        node.prev = head;
        head.next.prev = node;
        head.next = node;
    }

    private Node<K,V> removeLast() {
        Node<K,V> node = tail.prev;
        remove(node);
        return node;
    }

    private static class Node<K, V> {
        K key;
        V value;
        Node<K,V> prev;
        Node<K,V> next;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
        }
    }
}

在这个例子中，我们使用了一个哈希表cache来存储缓存数据的键值对，同时使用了一个双向链表来维护缓存数据的访问顺序，其中head和tail分别表示链表头和链表尾，每次访问缓存时，我们将访问的数据节点移动到链表头，当缓存满时，淘汰链表尾部的节点即可。

注意，为了方便起见，我们在链表头和链表尾分别添加了一个哨兵节点head和tail，这样就不需要在代码中处理链表为空的情况了。

下面是一个使用双向链表实现LRU缓存淘汰算法的例子，假设我们要实现一个最大容量为3的缓存：

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

class LRUCache<K, V> {
    private int capacity;
    private Map<K, Node<K,V>> cache;
    private Node<K,V> head;
    private Node<K,V> tail;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.cache = new HashMap<>();
        this.head = new Node<>(null, null);
        this.tail = new Node<>(null, null);
        this.head.next = this.tail;
        this.tail.prev = this.head;
    }

    public V get(K key) {
        if (!cache.containsKey(key)) {
            return null;
        }
        Node<K,V> node = cache.get(key);
        remove(node);
        addFirst(node);
        return node.value;
    }

    public void put(K key, V value) {
        if (cache.containsKey(key)) {
            Node<K,V> node = cache.get(key);
            node.value = value;
            remove(node);
            addFirst(node);
        } else {
            if (cache.size() == capacity) {
                Node<K,V> node = removeLast();
                cache.remove(node.key);
            }
            Node<K,V> node = new Node<>(key, value);
            cache.put(key, node);
            addFirst(node);
        }
    }

    private void remove(Node<K,V> node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private void addFirst(Node<K,V> node) {
        node.next = head.next;
        node.prev = head;
        head.next.prev = node;
        head.next = node;
    }

    private Node<K,V> removeLast() {
        Node<K,V> node = tail.prev;
        remove(node);
        return node;
    }

    private static class Node<K, V> {
        K key;
        V value;
        Node<K,V> prev;
        Node<K,V> next;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
        }
    }
}

注意，为了方便起见，我们在链表头和链表尾分别添加了一个哨兵节点head和tail，这样就不需要在代码中处理链表为空的情况了。

到此这篇关于JavaScript如何实现LRU缓存淘汰算法的文章就介绍到这了,更多相关JavaScript LRU缓存淘汰算法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

NestJs使用Mongoose对MongoDB操作的方法
这篇文章主要介绍了NestJs使用Mongoose对MongoDB操作的方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2021-02-02
解读函数的节流与防抖问题
这篇文章主要介绍了解读函数的节流与防抖问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-12-12
解决Js先触发失去焦点事件再执行点击事件的问题
今天小编就为大家分享一篇解决Js先触发失去焦点事件再执行点击事件的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2018-08-08
JavaScript高级程序设计阅读笔记（十三） js定义类或对象
js定义类或对象的介绍，需要的朋友可以参考下
2012-08-08
JavaScript async/await使用详解
任意一个名称都是有意义的，先从字面意思来理解。async 是“异步”的简写，而 await 可以认为是 async wait 的简写。所以应该很好理解 async 用于申明一个 function 是异步的，而 await 用于等待一个异步方法执行完成
2022-12-12
JavaScript 事件对内存和性能的影响
本文主要介绍了JavaScript 事件对内存和性能的影响。具有很好的参考价值，下面跟着小编一起来看下吧
2017-01-01
解决bootstrap中下拉菜单点击后不关闭的问题
今天小编就为大家分享一篇解决bootstrap中下拉菜单点击后不关闭的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2018-08-08
JS中数据类型的正确判断方法实例
怎么去判断一个数据属于哪个数据类型,这个是很常见的操作,我们一般都会想到typeof和instanceof这两个常见的方法,但有时候这两种方法并不能满足我们的需求,下面这篇文章主要给大家介绍了关于JS中数据类型的正确判断方法,需要的朋友可以参考下
2021-08-08
JavaScript获取一个范围内日期的方法
这篇文章主要介绍了JavaScript获取一个范围内日期的方法,涉及javascript操作日期的相关技巧,需要的朋友可以参考下
2015-04-04
TypeScript枚举的基础知识及实例
使用枚举我们可以定义一些带名字的常量,使用枚举可以清晰地表达意图或创建一组有区别的用例,下面这篇文章主要给大家介绍了关于TypeScript枚举的基础知识及实际用例,需要的朋友可以参考下
2021-10-10