LRU Cache

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.

struct Node

{

    int key;

    int value;

    Node* left;

    Node* right;

    Node(){left=NULL;right=NULL;}

};

class LRUCache{

private:

    map<int,Node*> hashmap;

    Node* head;

    Node* tail;

    int capacity;

    int size;

    void remove(Node* p)

    {

        if(p==tail) tail=tail->left;

        if(p==head) head=head->right;

        if(p->left!=NULL)

            p->left->right=p->right;

        if(p->right!=NULL)

            p->right->left=p->left;

        p->left=NULL;

        p->right=NULL;

    }

    void insertfront(Node* p)

    {

        //insert 1st location

        p->left=NULL;

        p->right=head;

        if(head!=NULL) head->left=p;

        head=p;

        if(tail==NULL) tail=head;

    }

    void insertback(Node* p)

    {

        //insert 1st location

        p->left=tail;

        p->right=NULL;

        tail=p;

        if(head==NULL) head=tail;

    }

public:

    LRUCache(int capacity) 

    {

        this->capacity=capacity;

        size=0;

        head=NULL;

        tail=NULL;

    }

    

    int get(int key) 

    {

       map<int ,Node*>::iterator it;

       it=hashmap.find(key);

       if(it==hashmap.end()) return -1;

       

       Node* pnew=it->second;

       remove(pnew);

       insertfront(pnew);

       

       return pnew->value;

    }

    

    void set(int key, int value) 

    {

        map<int ,Node*>::iterator it;

       it=hashmap.find(key);

       Node* pnew;

       if(it!=hashmap.end())

       {

           pnew=it->second;

           pnew->value=value;

           remove(pnew);

           insertfront(pnew);

       }

       else

       {

           if(size<capacity)

           {

               pnew=new Node();

               pnew->key=key;

               pnew->value=value;

               hashmap.insert(pair<int,Node*>(key,pnew));

               

               insertfront(pnew);

               size++;

           }

           else

           {

               pnew=tail;

               hashmap.erase(hashmap.find(pnew->key));

               

               pnew->key=key;

               pnew->value=value;

               hashmap.insert(pair<int,Node*>(key,pnew));

               

               remove(pnew);

               insertfront(pnew);

           }

       }

    }

};