LRU Cache

------QUESTION------

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

class LRUCache{
private:
    struct ListNode{
        ListNode * prev;
        ListNode * next;
        int key;
        int value;
        ListNode(int _key, int _value):key(_key), value(_value), prev(NULL), next(NULL){}  
    };   
    void change2TopPriotiy(ListNode* listNode){
        if(head==listNode) return;
        listNode->prev->next = listNode->next;
        if(listNode->next) listNode->next->prev = listNode->prev;
        else tail = tail->prev;
        listNode->prev = NULL;
        listNode->next = head;
        head->prev = listNode;
        head = head->prev;
    }
public:
    LRUCache(int capacity) {
        listNodeMap.clear();
        this->capacity = capacity;
        head = NULL;
        tail = NULL;
    }
    
    int get(int key) {
        if(listNodeMap.find(key)!=listNodeMap.end()){
            change2TopPriotiy(listNodeMap[key]);
            return listNodeMap[key]->value;
        }
        else return -1;
    }
    
    void set(int key, int value) {
        if(listNodeMap.find(key)==listNodeMap.end()){ // ket not exist
            if(listNodeMap.size()==capacity){ // reach the capacity
                //erase least used data
                listNodeMap.erase(tail->key);
                ListNode * tmp = tail;
                if(head == tail) {
                    head = tail = NULL;
                }
                else{
                    tail = tail->prev;
                    tail->next = NULL;
                }
                delete tmp;
            }
            //insert new node
            ListNode * newNode = new ListNode(key,value);
            if(!head){ //first node in the list
                head = tail = newNode;
            }
            else{
                head->prev = newNode;
                newNode->next = head;
                head = head->prev;
            }
            listNodeMap[key]=newNode;
        }
        else{ //key already exists, change the value. eg: set(2,1),set(2,2),get(2) return 2
            listNodeMap[key]->value = value;
            change2TopPriotiy(listNodeMap[key]);
        }
    }
private:
    unordered_map< int,ListNode* > listNodeMap;
    ListNode* head;
    ListNode* tail;
    int capacity;
};