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