146. LRU缓存机制

题目

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。

进阶:

你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例:

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 该操作会使得密钥 2 作废
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 该操作会使得密钥 1 作废
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

分析：

O(1) 时间复杂度内完成这两种操作，查找、删除考虑使用hash，但是还要维护一个先入先出的队列，需要使用双端队列。双端队列是因为删除中间某一个元素时好维护。

大概就是上图的情况，使用hashmap可以快速找到对应的节点，而链表维护了我们想要的顺序。

代码

class LRUCache {
    private Map<Integer,Node> map = new HashMap<>();
    private int capacity;
    Node head = new Node(-1, -1);
    Node tail = new Node(-1, -1);

    public LRUCache(int capacity) {
        head.next = tail;
        tail.pre = head;
        this.capacity = capacity;
    }

    public int get(int key) {
        if (!map.containsKey(key)){
            return -1;
        }
        Node node = map.get(key);
        delete(node);
        add(node);
        return node.value;
    }

    public void put(int key, int value) {
        //已存在
        if (map.containsKey(key)){
            delete(map.get(key));
        }else if (map.size() >= capacity){
            //删除最近不用的
            delete(head.next);
        }
        //插到队尾
        Node node = new Node(key, value);
        add(node);
    }

    /**
     * 删除一个节点 除了头尾
     */
    private void delete(Node node){
        if (head == node || tail == node){
            return;
        }
        map.remove(node.key);
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }
    /**
     * 新增节点到队尾
     * @param node
     */
    private void add(Node node){
        node.next = tail;
        node.pre = tail.pre;
        tail.pre.next = node;
        tail.pre = node;
        map.put(node.key,node);
    }
}
class Node{
    int key,value;
    Node next,pre;

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

除了自己实现这种数据结构，还可以使用Java官方提供的LinkedHashMap.

LinkedHashMap是HashMap的子类，但是内部还有一个双向链表维护键值对的顺序，每个键值对既位于哈希表中，也位于双向链表中。LinkedHashMap支持两种顺序插入顺序 、 访问顺序

• 插入顺序：先添加的在前面，后添加的在后面。修改操作不影响顺序
• 访问顺序：所谓访问指的是get/put操作，对一个键执行get/put操作后，其对应的键值对会移动到链表末尾，所以最末尾的是最近访问的，最开始的是最久没有被访问的，这就是访问顺序。

指定按照访问顺序排序

LinkedHashMap有5个构造方法，其中4个都是按插入顺序，只有一个是可以指定按访问顺序：

public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)
其中参数accessOrder就是用来指定是否按访问顺序，如果为true，就是访问顺序。

在LinkedHashMap添加元素后，会调用removeEldestEntry防范，传递的参数时最久没有被访问的键值对，如果方法返回true，这个最久的键值对就会被删除。LinkedHashMap中的实现总返回false，该子类重写后即可实现对容量的控制

class LRUCache extends LinkedHashMap<Integer,Integer>{
    int n;
    public LRUCache(int capacity) {
        //第二个参数为hashmap负载系数  0-1 第三个选择访问顺序
        super(capacity,0.5F,true);
        n = capacity;
    }

    public int get(int key) {
        if (!super.containsValue(key)){
            return -1;
        }
        return super.get(key);
    }

    public void put(int key, int value) {
        super.put(key,value);
    }
    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        return size() > n;
    }

}