LeetCode

LRU Cache

2014.2.13 18:15

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

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(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.

Solution:

　　My LRU cache is made up of two parts, a hash table and a double-linked list.

　　Hash table provides O(1) access to every element in the cache. Double-linked list allows you to move a node to the head or to the tail in O(1) time, although you'll need O(n) time locating this node. With their combiantion, both process can reach O(1) complexity.

　　The double-linked list is handwritten, while the hash table is unordered_map from new STL.

　　It's quite easy to make mistake on linked list, especially when it is double-linked.

　　Whenever set() or get() is called, the node visitied or created should be put on the front of the list.

　　Time complexity is O(1) for both set() and get(), linked list and hashing both use O(n) space.

Accepted code:

// 1WA, 1AC, double-linked list + unordered_map
#include <unordered_map>
using  namespace std;

typedef struct DoubleLinkedListNode{
public:
    int key;
    int value;
    struct DoubleLinkedListNode *left;
    struct DoubleLinkedListNode *right;
    DoubleLinkedListNode(int _key = 0, int _value = 0): key(_key), value(_value), left(nullptr), right(nullptr) {}
}DoubleLinkedListNode;

class LRUCache{
public:
    LRUCache(int capacity) {
        this->capacity = capacity;
        this->size = 0;
        this->head = this->tail = nullptr;
        this->hash_table.clear();
    }
    
    int get(int key) {
        if (size == 0) {
            // the LRU cache is empty.
            return KEY_NOT_FOUND;
        }
        
        unordered_map<int, DoubleLinkedListNode *>::iterator mit;
        
        mit = hash_table.find(key);
        if (mit != hash_table.end()) {
            // the key exists in the cache.
            DoubleLinkedListNode *ptr = mit->second;
            if (ptr == head) {
                // do nothing
            } else if (ptr == tail) {
                // ptr is the tail node.
                tail = ptr->left;
                tail->right = nullptr;
                ptr->left = nullptr;
                ptr->right = head;
                head->left = ptr;
                head = ptr;
            } else {
                // ptr is at middle of the list.
                DoubleLinkedListNode *ptr1, *ptr2;
                ptr1 = ptr->left;
                ptr2 = ptr->right;
                ptr1->right = ptr2;
                ptr2->left = ptr1;
                ptr->left = nullptr;
                ptr->right = head;
                head->left = ptr;
                head = ptr;
            }
            return ptr->value;
        } else {
            // key not found.
            return KEY_NOT_FOUND;
        }
    }
    
    void set(int key, int value) {
        if (capacity == 0) {
            // no room to place anything.
            return;
        }
        
        unordered_map<int, DoubleLinkedListNode *>::iterator mit;
        mit = hash_table.find(key);
        if (mit != hash_table.end()) {
            // the key exists in the cache.
            DoubleLinkedListNode *ptr = mit->second;
            if (ptr == head) {
                // do nothing
            } else if (ptr == tail) {
                // ptr is the tail node.
                tail = ptr->left;
                tail->right = nullptr;
                ptr->left = nullptr;
                ptr->right = head;
                head->left = ptr;
                head = ptr;
            } else {
                // ptr is at middle of the list.
                DoubleLinkedListNode *ptr1, *ptr2;
                ptr1 = ptr->left;
                ptr2 = ptr->right;
                ptr1->right = ptr2;
                ptr2->left = ptr1;
                ptr->left = nullptr;
                ptr->right = head;
                head->left = ptr;
                head = ptr;
            }
            ptr->value = value;
        } else {
            DoubleLinkedListNode *ptr = nullptr;
            if (size < capacity) {
                // still some space left.
                // put the new item at front, not rear.
                ptr = new DoubleLinkedListNode(key, value);
                if (head != nullptr) {
                    head->left = ptr;
                    ptr->right = head;
                } else {
                    tail = ptr;
                }
                head = ptr;
                hash_table[key] = ptr;
                ++size;
            } else {
                // capacity is reached.
                ptr = tail;
                hash_table.erase(tail->key);
                ptr->key = key;
                ptr->value = value;
                if (head != tail) {
                    tail = ptr->left;
                    tail->right = nullptr;
                    ptr->left = nullptr;
                    ptr->right = head;
                    head->left = ptr;
                    head = ptr;
                }
                hash_table[key] = ptr;
            }
        }
    }
private:
    static const int KEY_NOT_FOUND = -1;
    int capacity;
    int size;
    DoubleLinkedListNode *head;
    DoubleLinkedListNode *tail;
    unordered_map<int, DoubleLinkedListNode *> hash_table;
};