实现LRU缓存

题目描述

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。 实现 LRUCache 类：
LRUCache(int capacity) ：
以正整数作为容量 capacity 初始化 LRU 缓存
int get(int key)：
如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value)：
如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
要求：在 O(1) 时间复杂度内完成这两种操作。
示例：
输入 ：[“LRUCache”, “put”, “put”, “get”, “put”, “get”, “put”, “get”, “get”, “get”] [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出 ：[null, null, null, 1, null, -1, null, -1, 3, 4]

解释 ：
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1作废，缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4
提示：
1 <= capacity <= 3000
0 <= key <= 3000
0 <= value <= 104
最多调用 3 * 104次 get 和 put

方法一（有序哈希）

1.解题思路

• 首先在构造函数里，初始化一个LinkedHashMap和一个容量
• 对于get方法，当map中不存在当前键时，直接返回-1；存在当前键时，获取对应的值，删除原来的位置，并插入到有序map头部，最后返回当前键对应的值。
• 对于put方法，当map中不存在当前键时，需要考虑是否能存下新的键，如果已经达到了capacity的容量，则需要执行LRU淘汰策略，删除掉map尾部的键，然后将当前key和value存入到map；存在当前键时，删除原来的位置，并插入到有序map的头部，并跟新value值。

2.代码实现

class LRUCache {

    int capacity;
    LinkedHashMap<Integer,Integer> map;

    public LRUCache(int capacity) {
        this.map=new LinkedHashMap<>();
        this.capacity=capacity;
    }
    
    public int get(int key) {
        if(!map.containsKey(key)){
            return -1;
        }       
        int value=map.remove(key);
        map.put(key,value);
        return value;
    }
    
    public void put(int key, int value) {
        if(!map.containsKey(key)){
            if(map.size()==capacity){
                map.remove(map.entrySet().iterator().next().getKey());
            }
            map.put(key,value);
        }
        else{
            map.remove(key);
            map.put(key,value);
        }
       
    }
}

3.复杂度分析

• 时间复杂度：有序map的删除、插入操作时间复杂度均为O(1)，所以时间复杂度为O(1)。
• 空间复杂度：假设缓存的容量capacity的大小最大为n，最多可以存n个元素，所以空间复杂度为O(n)。

方法二（双向链表+哈希）

1.解题思路

思路和方法一大致相同，不过自己构造了双向链表进行实现，比较考验代码功底。
核心方法是双向链表的removeNode()和addToHead()这两个方法。

2.代码实现

class LRUCache {
	//双向链表
    class Node{
        int key;
        int value;
        Node prev;
        Node next;
        public Node(){}
        public Node(int key,int value){
            this.key=key;
            this.value=value;
        }
    }

    int capacity;
    Map<Integer,Node> map;
    Node head;
    Node tail;
	//初始化缓存容量，map和双向链表
    public LRUCache(int capacity) {
        this.capacity=capacity;
        this.map=new HashMap<>();
        this.head=new Node();
        this.tail=new Node();
        head.next=tail;
        tail.prev=head;
    }
    
    public int get(int key) {

        if(!map.containsKey(key)){
            return -1;
        }     
        Node node=map.get(key);
        //跟新缓存中位置  
        removeNode(node);
        addToHead(node);
        return node.value;
    }
    
    public void put(int key, int value) {
        
        if(!map.containsKey(key)){
        	//执行淘汰策略
            if(map.size()==capacity){
                Node node=tail.prev;
                map.remove(node.key);
                removeNode(node);          
            }
            //从头部插入缓存
            Node newNode=new Node(key,value);
            map.put(key,newNode);
            addToHead(newNode);          
        }
        else{
            Node node=map.get(key);
            //跟新value
            node.value=value;
            //跟新缓存中位置
            removeNode(node);
            addToHead(node);
        }       
            
    }

	//删除双向链表指定节点
    private void removeNode(Node node){
        node.prev.next=node.next;
        node.next.prev=node.prev;
    }

	//从双向链表头部插入节点
    private void addToHead(Node node){
        node.prev=head;
        node.next=head.next;
        head.next.prev=node;
        head.next=node;
    }
}

3.复杂度分析

• 时间复杂度：由于双向链表的removeNode()和addToHead()方法时间复杂度都是O(1)，map的get()、remove()、put()的时间复杂度也是O(1)，所以时间复杂度为O(1)。
• 空间复杂度：假设缓存的容量capacity的大小最大为n，最多可以存n个元素，所以空间复杂度为O(n)。