算法题：LRU

LRU（Least Recently Used，最近最少使用）算法是一种常用的页面置换算法，用于管理缓存中的数据，以保证缓存中的数据都是最近被访问过的。这种算法通过维护一个数据项的访问历史来工作，从而当缓存空间不足时，可以移除最长时间未被访问的数据项，以便为新的数据项腾出空间。

LRU算法原理

LRU算法基于以下假设：如果一个数据项在最近一段时间被访问过，那么它很可能在不久的将来再次被访问。因此，当缓存满时，LRU算法会移除最久未被访问的数据项。

在实现上，LRU算法通常需要一个哈希表（HashMap）来存储数据项及其键的映射，以便快速访问任何数据项；同时需要一个双向链表（Doubly Linked List）来保持数据项的使用顺序，链表头部存储最近访问的数据项，链表尾部存储最久未访问的数据项。

手写一个LRU

以下是一个使用Java实现的简单LRU缓存的示例：

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

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

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

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

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

    public V get(K key) {
        if (!cache.containsKey(key)) {
            return null;
        }

        Node<K, V> node = cache.get(key);
        moveToHead(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;
            moveToHead(node);
            return;
        }

        if (cache.size() == capacity) {
            // 删除最近最少使用的元素（尾部元素）
            K tailKey = tail.prev.key;
            cache.remove(tailKey);
            removeNode(tail.prev);
        }

        // 在头部添加新元素
        Node<K, V> newNode = new Node<>(key, value);
        cache.put(key, newNode);
        addNode(newNode);
    }

    private void moveToHead(Node<K, V> node) {
        removeNode(node);
        addNode(node);
    }

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

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

这个LRUCache类实现了LRU缓存策略。它使用了一个HashMap（cache）来存储键值对，并同时记录每个键对应的双向链表节点。双向链表用来维护访问顺序，最近访问的节点在链表头部，最久未访问的节点在链表尾部。当缓存满时，最久未使用的节点（尾部节点）将被淘汰。

你可以像这样使用它：

LRUCache<Integer, Integer> cache = new LRUCache<>(2);
cache.put(1, 1);
cache.put(2, 2);
System.out.println(cache.get(1)); // 返回 1
cache.put(3, 3);    // 淘汰键 2
System.out.println(cache.get(2)); // 返回 null (未找到)
cache.put(4, 4);    // 淘汰键 1
System.out.println(cache.get(1)); // 返回 null (未找到)
System.out.println(cache.get(3)); // 返回 3
System.out.println(cache.get(4)); // 返回 4

Java代码示例

在Java中，我们可以使用LinkedHashMap来实现一个简单的LRU缓存，因为LinkedHashMap提供了按访问顺序排序的能力（通过设置其accessOrder属性为true）。但是，请注意，Java标准库并没有直接提供标准的LRU缓存实现，所以下面的例子仅作为教学和演示使用。

import java.util.LinkedHashMap;
import java.util.Map;

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;

    public LRUCache(int capacity) {
        // true 表示让 LinkedHashMap 按照访问顺序来进行排序，最近访问的放在头部，最老访问的放在尾部。
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        // 当Map中的数据量大于指定的缓存个数的时候，就自动删除最老的数据。
        return size() > capacity;
    }

    public static void main(String[] args) {
        LRUCache<Integer, String> cache = new LRUCache<>(3);
        cache.put(1, "a");
        cache.put(2, "b");
        cache.put(3, "c");

        System.out.println(cache); // 输出可能类似于 {1=a, 2=b, 3=c}

        cache.get(1); // 访问key为1的元素，将其移动到最近访问的位置
        cache.put(4, "d"); // 该操作会导致最久未访问的 key 为 2 的元素被移除

        System.out.println(cache); // 输出可能类似于 {3=c, 1=a, 4=d}
    }
}

在上面的代码中，LRUCache类继承自LinkedHashMap，并重写了removeEldestEntry方法。此方法会在每次添加新元素时被调用，如果缓存已满（即大小超过了capacity），则会移除最老（最久未访问）的元素。此外，我们还利用了LinkedHashMap的访问顺序特性，在访问某个元素时，它会自动将该元素移到链表的头部，从而成为最近访问的元素。

注意：LinkedHashMap的性能取决于其底层实现，通常它的时间复杂度是O(1)的，但对于哈希冲突的处理可能会引入额外的开销。因此，虽然上述实现对于一般应用是足够的，但在高并发或极端性能要求的场景下，可能需要考虑更高效的实现方式。