146 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.

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

Example:

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

实现LRU
用map+双向链表


C++：

class LRUCache {
private:
    struct Node{
        int key ;
        int value ;
        Node* left ;
        Node* right ;
        Node(int k , int v): key(k) , value(v) , left(NULL) , right(NULL) {}
    };
    
    int capacity ;
    unordered_map<int,Node*> hash ;
    Node* head ;
    Node* tail ;
    
    void deleteNode(Node * node){
        node->left->right = node->right ;
        node->right->left = node->left ;
    }
    
    void insertToTail(Node * node){
        Node* last = tail->left ;
        node->right = tail ;
        node->left = last ;
        tail->left = node ;
        last->right = node ;
    }
    
public:
    LRUCache(int capacity) {
        this->capacity = capacity ;
        this->head = new Node(0,0) ;
        this->tail = new Node(0,0) ;
        head->right = this->tail ;
        tail->left = this->head ;
    }
    
    int get(int key) {
        if (hash.count(key) == 0){
            return -1 ;
        }else{
            deleteNode(hash[key]) ;
            insertToTail(hash[key]) ;
            return hash[key]->value ;
        }
    }
    
    void put(int key, int value) {
        if (hash.count(key) != 0){
            deleteNode(hash[key]) ;
            insertToTail(hash[key]) ;
            hash[key]->value = value ;
        }else{
            if (hash.size() < this->capacity){
                Node* node = new Node(key,value) ;
                insertToTail(node) ;
                hash[key] = node ;
            }else{
                Node* node = head->right ;
                deleteNode(node) ;
                insertToTail(node) ;
                hash.erase(node->key) ;
                hash[key] = node ;
                node->key = key ;
                node->value = value ;
            }
        }
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

java:

class LRUCache {
    
    class ListNode{
        int key ;
        int value ;
        ListNode pre ;
        ListNode next ;
    }
    

    
    private void deleteNode(ListNode node){
        node.pre.next = node.next ;
        node.next.pre = node.pre ;
    }
    
    private void insertNode(ListNode node){
        ListNode p = head.next ;
        node.pre = head ;
        node.next = p ;
        head.next = node ;
        p.pre = node ;
    }
    
    private Map<Integer,ListNode> map = new HashMap<Integer,ListNode>() ;
    private ListNode head ;
    private ListNode tail ;
    private int count = 0 ;
    private int capacity ;

    public LRUCache(int capacity) {
        head = new ListNode() ;
        tail = new ListNode() ;
        head.pre = null ;
        head.next = tail ;
        tail.pre = head ;
        tail.next = null ;
        this.capacity = capacity ;
    }
    
    public int get(int key) {
        ListNode node = map.get(key) ;
        if (node == null){
            return -1 ;
        }else{
            deleteNode(node) ;
            insertNode(node) ;
            return node.value ;
        }
    }
    
    public void put(int key, int value) {
        ListNode node = map.get(key) ;
        if (node == null){
            ListNode newNode = new ListNode();
            newNode.key = key;
            newNode.value = value;
            map.put(key,newNode) ;
            insertNode(newNode) ;
            count++ ;
            if (count > capacity){
                ListNode last = tail.pre ;
                deleteNode(last) ;
                count-- ;
                map.remove(last.key) ;
            }
        }else{
            node.value = value ;
            deleteNode(node) ;
            insertNode(node) ;
        }
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */