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.

  1 struct node{
  2     int key;
  3     int value;
  4     node* pre;
  5     node* next;
  6 };
  7 class LRUCache{
  8 private:
  9      int count;
 10      int size;
 11      map<int,node*> mp;
 12      node* cachehead;
 13      node* cachetail;
 14 public:
 15     LRUCache(int capacity) {
 16         count=0;
 17         size=capacity;
 18        
 19         cachehead=NULL;
 20         cachetail=NULL;
 21     }
 22     
 23     int get(int key) {
 24         if(cachehead==NULL) return -1;
 25         map<int,node*>::iterator it=mp.find(key);
 26         if(it==mp.end())
 27             return -1;
 28         else
 29         {
 30             node* p=it->second;
 31             pushfront(p);
 32                 //p->pre->next=p->next;
 33                 /*if(p->next!=NULL)
 34                     p->next->pre=p->pre;
 35                 mp.erase(p->key);
 36                 p->next=cachehead;
 37                 p->pre=cachehead->pre;
 38                 cachehead->pre=p;
 39                 cachehead=cachehead->pre;
 40                 mp[cachehead->key]=cachehead;*/
 41             
 42         }
 43         return cachehead->value;
 44     }
 45     
 46     void set(int key, int value) {
 47         if(cachehead==NULL)
 48         {
 49             cachehead=(node*)malloc(sizeof(node));
 50             cachehead->key=key;
 51             cachehead->value=value;
 52             cachehead->pre=NULL;
 53             cachehead->next=NULL;
 54             mp[key]=cachehead;
 55             cachetail=cachehead;
 56             count++;
 57         }
 58         else
 59         {
 60             map<int,node*>::iterator it=mp.find(key);
 61             if(it==mp.end())
 62             {
 63                 if(count==size)
 64                 {
 65                     if(cachehead==cachetail&&cachehead!=NULL)
 66                     {
 67                         mp.erase(cachehead->key);
 68                         cachehead->key=key;
 69                         cachehead->value=value;
 70                         mp[key]=cachehead;
 71                     }
 72                     else
 73                     {
 74                         node* p=cachetail;
 75                         cachetail->pre->next=cachetail->next;
 76                         cachetail=cachetail->pre;
 77                         
 78                         mp.erase(p->key);
 79                         
 80                         p->key=key;
 81                         p->value=value;
 82                         
 83                         p->next=cachehead;
 84                         p->pre=cachehead->pre;
 85                         cachehead->pre=p;
 86                         cachehead=p;
 87                         mp[cachehead->key]=cachehead;
 88                     }
 89                     
 90                 }
 91                 else
 92                 {
 93                     node* p=(node*)malloc(sizeof(node));
 94                     p->key=key;
 95                     p->value=value;
 96                     p->next=cachehead;
 97                     p->pre=cachehead->pre;
 98                     cachehead->pre=p;
 99                     cachehead=p;
100                     mp.erase(p->key);
101                     mp[cachehead->key]=cachehead;
102                     count++;
103                 }
104             }
105             else
106             {
107                 
108                 node* p=it->second;
109                 p->value=value;
110                 pushfront(p);
111              /*   mp.erase(p->key);
112                 
113                 p->pre->next=p->next;
114                 if(p->next!=NULL)
115                     p->next->pre=p->pre;
116                 p->value=value;
117                 p->next=cachehead;
118                 p->pre=cachehead->pre;
119                 cachehead->pre=p;
120                 cachehead=cachehead->pre;
121                 mp[cachehead->key]=cachehead;*/
122             }
123         }
124         
125             
126     }
127     void pushfront(node* cur)
128     {
129         if(count==1)
130             return;
131         if(cur==cachehead) return;
132         if(cur==cachetail)
133             cachetail=cur->pre;
134         cur->pre->next=cur->next;
135         if(cur->next!=NULL)
136           cur->next->pre=cur->pre;
137         cur->next=cachehead;
138         cur->pre=cachehead->pre;
139         cachehead->pre=cur;
140         cachehead=cur;
141     }
142 
143 };