leetcode:LRU Cache

  1 /*
  2     Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.
  3 
  4     get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
  5     set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, 
  6                   it should invalidate the least recently used item before inserting a new item. 
  7     Problem link: https://oj.leetcode.com/problems/lru-cache/
  8 
  9     Author: Vincent Zhang
 10 */
 11 
 12 #include <map>
 13 using namespace std;
 14 
 15 struct CacheNode {
 16     int key;
 17     int value;
 18     CacheNode* prev;
 19     CacheNode* next;
 20     CacheNode(int k,int v) : key(k), value(v), prev(NULL), next(NULL) {}
 21 };
 22 
 23 class LRUCache{
 24 public:
 25     LRUCache(int capacity) {
 26         this->cache_capacity = capacity;
 27         head = NULL;
 28         tail = NULL;        
 29     }
 30 
 31     int get(int key) {
 32         map<int,CacheNode*>::iterator it = cache_map.find(key);
 33         if (it == cache_map.end())
 34             return -1;
 35         else
 36         {
 37             CacheNode *tp = it->second;
 38             moveToHead(tp);
 39             return tp->value;
 40         }
 41     }
 42 
 43     void set(int key, int value) {
 44         map<int,CacheNode*>::iterator it = cache_map.find(key);
 45         // new key and value
 46         if (it == cache_map.end())
 47         {    
 48             // cache is full, release the LRU one and add new
 49             if (cache_map.size() == cache_capacity)
 50             {
 51                 cache_map.erase(tail->key);
 52                 tail->key = key;
 53                 tail->value = value;
 54                 CacheNode *tp = tail;
 55                 moveToHead(tp);
 56 
 57                 cache_map.insert(map<int,CacheNode*>::value_type(key,tp));
 58             }
 59             else    // cache is not full, add new
 60             {
 61                 CacheNode *newNode = new CacheNode(key,value);
 62                 attachToHead(newNode);
 63                 cache_map.insert(map<int,CacheNode*>::value_type(key,newNode));
 64             }
 65             
 66         }
 67         else    // has an exist node
 68         {
 69             CacheNode *tp = it->second;
 70             tp->value = value;
 71 
 72             isolateNode(tp);
 73             attachToHead(tp);
 74         }
 75 
 76     }
 77 private:
 78     int cache_capacity;
 79     CacheNode *head,*tail;
 80     map<int,CacheNode*> cache_map;
 81 
 82     void moveToHead(CacheNode *node)
 83     {
 84         if (node == head)
 85             return;
 86         else
 87         {
 88             isolateNode(node);
 89             attachToHead(node);
 90         }
 91     }
 92     void isolateNode(CacheNode* node)
 93     {
 94         if (node->prev != NULL)        
 95             node->prev->next = node->next;
 96         else // node is head
 97             head = node->next;
 98         
 99         if (node->next !=NULL)
100             node->next->prev = node->prev;
101         else    // node is tail
102             tail = node->prev;
103 
104         node->next = NULL;
105         node->prev = NULL;        
106     }
107     void attachToHead(CacheNode* node)
108     {
109         // head is null, list is empty
110         if (head == NULL)
111         {
112             head = node;
113             tail = head;
114         }
115         else
116         {
117             node->next = head;
118             head->prev = node;
119             head = node;
120         }
121     }
122 };