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

 

 代码实现：

class LRUCache {
    // key -> Node(key, val)
    private HashMap<Integer, Node> map;
    // Node(k1, v1) <-> Node(k2, v2)...
    private DoubleList cache;
    // 最大容量
    private int cap;
    
    public LRUCache(int capacity) {
        this.cap = capacity;
        map = new HashMap<>();
        cache = new DoubleList();
    }
    
    public int get(int key) {
        if (!map.containsKey(key))
            return -1;
        int val = map.get(key).val;
        // 利用 put 方法把该数据提前
        put(key, val);
        return val;
    }
    
    public void put(int key, int val) {
        // 先把新节点 x 做出来
        Node x = new Node(key, val);
        
        if (map.containsKey(key)) {
            // 删除旧的节点，新的插到头部
            cache.remove(map.get(key));
            cache.addFirst(x);
            // 更新 map 中对应的数据
            map.put(key, x);
        } else {
            if (cap == cache.size()) {
                // 删除链表最后一个数据
                Node last = cache.removeLast();
                map.remove(last.key);
            }
            // 直接添加到头部
            cache.addFirst(x);
            map.put(key, x);
        }
    }
}

 

2. 基于LinkedHashMap实现

要实现LRU Cache，其实是要实现如何维持Cache的访问次序。HashMap的元素迭代顺序是不确定的，而LinkedHashMap正可以维持元素迭代顺序（插入顺序或访问顺序）。LinkedHashMap可以按访问顺序维持元素迭代顺序正好符合LRU Cache需求。
以下代码不是LeetCode的解题代码，该实现利用了泛型，更通用。

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private static final long serialVersionUID = 1L;
    // 缓存的容量 
    private int capacity;  
    LRUCache(int capacity){  
        // 调用LinkedHashMap的构造器
        // 初始容量initialCapacity = 16
        // 负载因子loadFactor = 0.75
        // accessOrder = true，表示按访问顺序迭代
        super(16, 0.75f, true);  
        this.capacity=capacity;  
    } 
    /** 
　　　* removeEldestEntry方法用于判断是否该删除最老元素（进入map最久或最久未被访问的元素） 
　　　* 在LinkedHashMap中，该方法放回false，相当于条件一直不满足，不会删除最老元素 
　　  * 当Map为Cache时，该方法非常有用，当map.size() > capacity时，删除最久未被访问的元素 */
    @Override  
    public boolean removeEldestEntry(Map.Entry<K, V> eldest){   
        return size() > capacity;  
    }