leetcode----146.LRU缓存(哈希表+双向链表)

146.LRU缓存(哈希表+双向链表)

问题：请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。
实现LRUCache 类：
LRUCache(int capacity)以 正整数 作为容量 capacity 初始化 LRU缓存
int get(int key) 如果关键字 key存在于缓存中，则返回关键字的值，否则返回-1。
void put(int key, int value) 如果关键字 key已经存在，则变更其数据值 value；如果不存在，则向缓存中插入该组 key-value。如果插入操作导致关键字数量超过 capacity，则应该 逐出 最久未使用的关键字。
函数get 和put必须以O(1)的平均时间复杂度运行。

思路： 首先需要确定用什么样的数据结构，链表是能满足LRU缓存约束的数据结构，我们默认越靠近头部的键值对为最近使用的关键字，则尾部即为最久未使用的关键字。因为get和put操作必须以O(1)的时间复杂度进行，所以需要使用哈希表进行优化，哈希表的key存关键字key，哈希表的value存放该关键字对应的链表节点。由于删除操作不仅需要知道后驱节点，还需要知道前驱节点，所以此题中的链表应该为双向链表。因此本次所采用的数据结构为哈希表+双向链表

接下来分析get和put操作：

• get操作相对比较简单，若关键字key存在缓存中，也就是哈希表中存在，则需要两个操作，

  • 第一是从哈希表中拿到key对应的链表节点node，并返回其value值
  • 第二是将此关键字对应的node挪到链表头部，即将该关键字标记为最近使用。

• put操作相对比较复杂

  • 首先需要判断该关键字是否存在，若存在，直接替换关键字对应的值即可
  • 若不存在，判断链表长度size是否大于等于缓存容量cap
    • 若大于等于，则说明需要删除最久未使用的关键字，为新插入的关键字留出空间，即删除双向链表中尾部节点。
    • 若小于，则直接将新关键字及其对应的值插入即可

class LRUCache {
    class Node {
        int key, value;
        Node prev, next;

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

    private int cap;
    private int size;
    private Map<Integer, Node> map = new HashMap();
    private Node head, tail;
    public LRUCache(int capacity) {
        cap = capacity;
        size = 0;
        head = new Node(0, 0);
        tail = new Node(0, 0);
        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int key) {
        if(!map.containsKey(key)){
            return -1;
        }

        Node node = map.get(key);
        moveTohead(node);
        return node.value;
    }
    
    public void put(int key, int value) {
        if(map.containsKey(key)){
            Node node = map.get(key);
            removeNode(node);
            node.value = value;
            addNode(node);
            map.put(key, node);
            return;
        }

        Node node = new Node(key, value);
        if(size >= cap){
            removeTail();
        }
        addNode(node);
    }
    
    //规定头部为最近使用的,尾部为最久未使用
    //添加一个元素
    private void addNode(Node node){
        node.next = head.next;
        node.prev = head;
        head.next.prev = node;
        head.next = node;
        map.put(node.key, node);
        size++;
    }
    
    //在链表中删除指定节点
    private void removeNode(Node node){
        node.prev.next = node.next;
        node.next.prev = node.prev;
        map.remove(node.key);
        size--;
    }
    
    //将某节点移动到头部   先删除再添加
    private void moveTohead(Node node){
        removeNode(node);
        addNode(node);
    }

    //删除最久未使用的节点，并返回。
    private Node removeTail(){
        if(head.next == tail){
            return null;
        }
        Node last = tail.prev;
        removeNode(last);
        return last;
    }
}

• 其实哈希表+双链表的数据结构就是java中的LinkedHashMap。思路同上，代码如下

class LRUCache {
    private int size;
    LinkedHashMap<Integer, Integer> cache = new LinkedHashMap<>();

    public LRUCache(int capacity) {
        this.size = capacity;
    }
    
    public int get(int key) {
        if(!cache.containsKey(key)){
            return -1;
        }

        makeRecently(key);
        return cache.get(key);
    }
    
    public void put(int key, int value) {
        if(cache.containsKey(key)){
            cache.put(key, value);
            makeRecently(key);
            return;
        }

        if(cache.size() >= this.size){
           int oldestKey = cache.keySet().iterator().next();
           cache.remove(oldestKey);
        }
        cache.put(key, value);
    }

    private void makeRecently(int key){
        int val = cache.get(key);
        cache.remove(key);
        cache.put(key, val);
    }
}