LRU Cache Code

class LRUCache {
public:
    class node {
        public:
        int val;
        int key;
        node *prev;
        node *next;
        node(int _key,int _val)
        {
            this->val = _val;
            this->key = _key;
        }
    };
        int cap;
        unordered_map<int, node*>mp;
      
        
    
      node *head = new node(-1,-1);
     node *tail = new node(-1,-1);
    
    void addNode(node *newnode)
    {
        node *temp= head->next;
        head->next = newnode;
        newnode->prev= head;
        newnode->next = temp;
        temp->prev = newnode;
    }
    
       void deleteNode(node *delNode)
    {
       node *nextNode = delNode->next;
       node *preNode = delNode->prev;
           preNode->next = nextNode;
           nextNode->prev = preNode;
    }
    
    
    
    LRUCache(int capacity) {
        cap =capacity;
        head->next=tail;
        tail->prev=head;
    }
    
    int get(int key) {
        
        if(mp.find(key)!=mp.end())
        {
            node *resnode = mp[key];
            int res = resnode->val;
            mp.erase(key);
            deleteNode(resnode);
            addNode(resnode);
            mp[key]=tail;
            return res;
        }
        
        return -1;
    }
    
    void put(int key, int value) {
         if(mp.find(key)!=mp.end())
        {
          
           
            deleteNode(mp[key]);
         mp.erase(key);
        }
       else if(mp.size()==cap)
       {
           mp.erase(tail->prev->key);
           deleteNode(tail->prev);
       }
        node *newNode = new node(key,value);
        addNode(newNode);
        mp[key]=head->next;
       return;
    }
};

/**
 * 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);
 */