資料結構與演算法 | 如何實現LRU快取淘汰演算法

原文連結：wangwei.one/posts/java-…

前面，我們學習了 連結串列 的實現，今天我們來學習連結串列的一個經典的應用場景——LRU淘汰演算法。

快取是一種提高資料讀取效能的技術，在硬體設計、軟體開發中都有著非常廣泛的應用，比如常見的 CPU 快取、資料庫快取、瀏覽器快取等等。

快取的大小有限，當快取被用滿時，哪些資料應該被清理出去，哪些資料應該被保留？這就需要快取淘汰策略來決定。常見的策略有三種：先進先出策略 FIFO（First In，First Out）、最少使用策略 LFU（Least Frequently Used）、最近最少使用策略 LRU（Least Recently Used），本篇將介紹LRU策略演算法。

LRU Cache

這一演算法的核心思想是，當快取資料達到預設的上限後，會優先淘汰掉近期最少使用的快取物件。

思路

LRU淘汰演算法涉及資料的新增與刪除，出於效能考慮，採用連結串列來進行實現，思路如下：

• 維護一個雙向連結串列用於存放快取資料，越接近連結串列尾部的資料表示越少被使用到。
• 放入一個資料時，如果資料已存在則將其移動到連結串列頭部，並更新Key所對應的Value值，如果不存在，則：
  • 如果快取容量已達到最大值，則將連結串列尾部節點刪除掉，將新的資料放入連結串列頭部；
  • 如果快取容量未達到最大值，則直接將新的資料放入連結串列頭部；
• 查詢一個資料時，遍歷整個連結串列，如果能查詢到對應的資料，則將其移動到連結串列頭部；如果查詢不到則返回null；
  • 由於遍歷連結串列的時間複雜度為O(n)，我們可以使用雜湊表HashMap來記錄每個Key所對應的Node節點，將時間複雜度降為O(1)。

程式碼

package one.wangwei.algorithms.utils;


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

/**
 * LRU Cache
 *
 * @author https://wangwei.one
 * @date 2019/01/29
 */
public class LRUCache<K, V> {

    private int capacity;
    private Node head;
    private Node tail;
    private Map<K, Node> nodeMap;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.nodeMap = new HashMap<>(capacity);
    }

    /**
     * Get Key
     *
     * @param key
     * @return
     */
    public V get(K key) {
        Node existNode = nodeMap.get(key);
        if (existNode == null) {
            return null;
        }
        remove(existNode);
        addFirst(existNode);
        return existNode.value;
    }

    /**
     * Add Key-Value
     *
     * @param key
     * @param value
     */
    public void put(K key, V value) {
        Node existNode = nodeMap.get(key);
        if (existNode == null) {
            Node newNode = new Node(key, value);
            if (nodeMap.size() >= capacity) {
                removeLast();
            }
            addFirst(newNode);
        }
        else {
            // update the value
            existNode.value = value;
            remove(existNode);
            addFirst(existNode);
        }
    }

    /**
     * remove node
     *
     * @param node
     */
    private void remove(Node node) {
        Node prev = node.prev;
        Node next = node.next;

        if (prev == null) {
            head = next;
        } else {
            prev.next = next;
        }
        if (next == null) {
            tail = prev;
        } else {
            next.prev = prev;
        }
        nodeMap.remove(node.key);
    }

    /**
     * add first node
     *
     * @param node
     */
    private void addFirst(Node node) {
        node.prev = null;
        if (head == null) {
            head = tail = node;
        } else {
            node.next = head;
            head.prev = node;
            head = node;
        }
        nodeMap.put(node.key, node);
    }

    /**
     * remove last
     */
    private void removeLast() {
        if (tail == null) {
            return;
        }
        // remove key from map
        nodeMap.remove(tail.key);
        // remove node from linked list
        Node prev = tail.prev;
        if (prev != null) {
            prev.next = null;
            tail = prev;
        } else {
            head = tail = null;
        }
    }

    private class Node {

        private K key;
        private V value;
        private Node prev;
        private Node next;

        private Node(K key, V value) {
            this.key = key;
            this.value = value;
        }
    }
}
複製程式碼

原始碼

LeetCode上相關的練習題：Leetcode 146. LRU Cache

效能測試：LeetCode上執行時間為88ms，超過了 43.42% 的Java程式碼。

相關練習

• 連結串列反轉
• 連結串列環檢測
• 有序連結串列合併
• 刪除倒數第N個節點
• 求連結串列的中間結點

參考資料

• 《資料結構與演算法之美》