JavaScript怎么實(shí)現(xiàn)LRU緩存淘汰算法

這篇文章主要講解了“JavaScript怎么實(shí)現(xiàn)LRU緩存淘汰算法”，文中的講解內(nèi)容簡單清晰，易于學(xué)習(xí)與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學(xué)習(xí)“JavaScript怎么實(shí)現(xiàn)LRU緩存淘汰算法”吧！

如何實(shí)現(xiàn)LRU緩存淘汰算法?

LRU（Least Recently Used）緩存淘汰算法是一種常見的緩存淘汰策略，它的核心思想是優(yōu)先淘汰最近最少使用的緩存數(shù)據(jù)，以保證緩存中的數(shù)據(jù)始終是最熱門的。

使用哈希表和雙向鏈表

LRU緩存淘汰算法的核心在于如何快速定位最近最少使用的緩存數(shù)據(jù)，這可以通過哈希表和雙向鏈表的結(jié)合來實(shí)現(xiàn)。具體來說，我們可以使用一個(gè)哈希表來存儲(chǔ)緩存數(shù)據(jù)的鍵值對(duì)，同時(shí)使用一個(gè)雙向鏈表來維護(hù)緩存數(shù)據(jù)的訪問順序，每次訪問緩存時(shí)，我們將訪問的數(shù)據(jù)節(jié)點(diǎn)移動(dòng)到鏈表頭，當(dāng)緩存滿時(shí)，淘汰鏈表尾部的節(jié)點(diǎn)即可。

哈希表實(shí)現(xiàn)LRU緩存淘汰算法

下面是一個(gè)使用哈希表實(shí)現(xiàn)LRU緩存淘汰算法的例子，假設(shè)我們要實(shí)現(xiàn)一個(gè)最大容量為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;
        }
    }
}

在這個(gè)例子中，我們使用了一個(gè)哈希表cache來存儲(chǔ)緩存數(shù)據(jù)的鍵值對(duì)，同時(shí)使用了一個(gè)雙向鏈表來維護(hù)緩存數(shù)據(jù)的訪問順序，其中head和tail分別表示鏈表頭和鏈表尾，每次訪問緩存時(shí)，我們將訪問的數(shù)據(jù)節(jié)點(diǎn)移動(dòng)到鏈表頭，當(dāng)緩存滿時(shí)，淘汰鏈表尾部的節(jié)點(diǎn)即可。

注意，為了方便起見，我們在鏈表頭和鏈表尾分別添加了一個(gè)哨兵節(jié)點(diǎn)head和tail，這樣就不需要在代碼中處理鏈表為空的情況了。

下面是一個(gè)使用雙向鏈表實(shí)現(xiàn)LRU緩存淘汰算法的例子，假設(shè)我們要實(shí)現(xiàn)一個(gè)最大容量為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;
        }
    }
}

在這個(gè)例子中，我們使用了一個(gè)哈希表cache來存儲(chǔ)緩存數(shù)據(jù)的鍵值對(duì)，同時(shí)使用了一個(gè)雙向鏈表來維護(hù)緩存數(shù)據(jù)的訪問順序，其中head和tail分別表示鏈表頭和鏈表尾，每次訪問緩存時(shí)，我們將訪問的數(shù)據(jù)節(jié)點(diǎn)移動(dòng)到鏈表頭，當(dāng)緩存滿時(shí)，淘汰鏈表尾部的節(jié)點(diǎn)即可。

注意，為了方便起見，我們在鏈表頭和鏈表尾分別添加了一個(gè)哨兵節(jié)點(diǎn)head和tail，這樣就不需要在代碼中處理鏈表為空的情況了。

感謝各位的閱讀，以上就是“JavaScript怎么實(shí)現(xiàn)LRU緩存淘汰算法”的內(nèi)容了，經(jīng)過本文的學(xué)習(xí)后，相信大家對(duì)JavaScript怎么實(shí)現(xiàn)LRU緩存淘汰算法這一問題有了更深刻的體會(huì)，具體使用情況還需要大家實(shí)踐驗(yàn)證。這里是億速云，小編將為大家推送更多相關(guān)知識(shí)點(diǎn)的文章，歡迎關(guān)注！