LRU算法

思路

1. 如果缓存中的值被访问就移到最前面
2. 如果缓存满了，仍在添加值，那么移除尾部的值，然后再添加值到头部
3. 使用哈希表+链表实现

Code

public class Node<V> {
    String key;
    V value;
    Node<V> prev;
    Node<V> next;

    public Node() {
    }

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

public class LruCache<V> {
    /**
     * 容量
     */
    private int initialCapacity = 1024;
    /**
     * 记录表
     */
    private Map<String, Node<V>> cache = new HashMap<>();
    /**
     * 头结点
     */
    private Node<V> head;
    /**
     * 尾结点
     */
    private Node<V> tail;

    public LruCache() {
        head = new Node<>();
        tail = new Node<>();
        head.next = tail;
        tail.prev = head;
    }

    public LruCache(int initialCapacity) {
        this();
        this.initialCapacity = initialCapacity;
    }

    public V get(String key) {
        Node<V> node = cache.get(key);
        //不存在key直接返回null
        if (null == node) {
            return null;
        }
        //node结点被访问，移到头部
        moveToHead(node);
        return node.value;
    }


    public void put(String key, V value) {
        Node<V> node = cache.get(key);
        if (null != node) {
            //node节点存在，修改值，移到表头
            node.value = value;
            moveToHead(node);
            return;
        }
        if (cache.size() == initialCapacity) {
            //超过容量，移除表尾节点
            Node<V> tail = removeTail();
            cache.remove(tail.key);
        }
        //构造新节点，添加进缓存，并添加到头部
        Node<V> resultNode = new Node<>(key, value);
        cache.put(key, resultNode);
        addHead(resultNode);
    }


    //移除节点
    private void remove(Node<V> node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    //节点添加到头部
    private void addHead(Node<V> node) {
        node.next = head.next;
        node.prev = head;
        head.next.prev = node;
        head.next = node;
    }

    //移动节点到头部
    private void moveToHead(Node<V> node) {
        remove(node);
        addHead(node);
    }

    //移除尾部节点
    private Node<V> removeTail() {
        Node<V> node = tail.prev;
        remove(node);
        return node;
    }
}

时间复杂度：O(1)

空间复杂度：O(1)