LeetCode 146. LRU Cache

[Med] LeetCode 146. LRU Cache

链接: https://leetcode.com/problems/lru-cache/

题目描述：

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and put.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
put(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

The cache is initialized with a positive capacity.

Follow up:
Could you do both operations in O(1) time complexity?

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

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

Example 1:

LRUCache cache = new LRUCache(2 capacity );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1); returns 1
cache.put(3, 3); evicts key 2
cache.get(2); returns -1 (not found)
cache.put(4, 4); evicts key 1
cache.get(1); returns -1 (not found)
cache.get(3); returns 3
cache.get(4); returns 4

---

Tag: Hash Map, Double Linkedlist
解题思路

用HashMap可以获得get O(1)的时间。用double LinkedList可以让插入变成O(1). 有几个点需要注意一下，head 和 tail一直是两个pointer, 不会改变，插入的值都是在head 和tail之间的。每一次get一个值，将它拿出来然后放在list的最前面。这样可以保证最后面的 removeLast()一定是最不常用的那一个。同时要考虑重复的值，有可能Key一样但是value不一样，需要更新

解法一:

class LRUCache {
    HashMap<Integer, Node> map;
    Node head, tail;
    int cap;
    public LRUCache(int capacity) {
        map = new HashMap<>();
        head = new Node(0,0);
        tail = new Node(0,0);
        head.next = tail;
        tail.prev = head;
        cap = capacity;
    }
    
    public int get(int key) {
        if(map.containsKey(key)){
            Node node = map.get(key);
            remove(node);
            addFirst(node);
            return node.value;
        }
        return -1 ;      
    }
    
    public void put(int key, int value) {
        if(map.containsKey(key)){
            remove(map.get(key));
            Node node = new Node(key, value);
            map.put(key, node);
            addFirst(node);
            return;
        }
        Node node = new Node(key, value);
        if(map.size()>=cap){
            removeLast();
        }
       
        map.put(key, node);
        addFirst(node);  
    }
    
    public void remove(Node node){
        Node p = node.prev;
        Node n = node.next;
        node.next =null;
        node.prev = null;
        p.next = n;
        n.prev  = p;
    }
    
    public void removeLast(){
        Node pp = tail.prev.prev;
        Node p = tail.prev;
        p.next = null;
        p.prev = null;
        pp.next = tail;
        tail.prev = pp;
        map.remove(p.key);
    }
    
    public void addFirst(Node node){
        node.next = head.next;
        head.next.prev = node;
        node.prev = head;
        head.next = node;
    }
    
}

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

解法二:

class LRUCache {
    Map<Integer, Node> map;
    int capacity;
    Node head = new Node(), tail = new Node();
    public LRUCache(int capacity) {
        map = new HashMap<>();
        this.capacity = capacity;

        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int key) {
        if(!map.containsKey(key)) return -1;
        Node node = map.get(key);
        remove(node);
        insert(key, node.val);
        return node.val;
    }
    
    public void put(int key, int value) {
        if(map.containsKey(key)){
            remove(map.get(key));    
        } 
        insert(key, value); 
        //先插入再删除比较不会容易出错
        if(map.size() > capacity) remove(tail.prev);
    }
    
    public void insert(int key, int value){
        Node n = new Node();
        n.key = key;
        n.val = value;

        n.next = head.next;
        head.next = n;
        n.next.prev = n;
        n.prev = head;
        map.put(key, n);
    }
    
    public void remove(Node n){
        Node prev = n.prev, next = n.next;

        prev.next = next;
        next.prev = prev;
        map.remove(n.key);
    }
}

class Node{
    Node next, prev;
    int key;
    int val;
    public Node(){}
}