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