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