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.
关于题意：
一开始以为LRU指的是在满的时候删除引用最少的节点。后来才发现是按访问时间来排序的最早的节点。
读懂题意之后就比较简单了：
1. 存储数据肯定是要用map的。
2. 怎样构建这个按访问时间排序的列表呢？这个列表需要能够快速增删。链表当然就最好。如果按时间插入，那么在删除时是删除表头，增加是在表尾。
3. 插入链表时，需要把原来的节点给删掉。链表删除需要在o(1)，只能用双向链表。而且当知道key的时候，需要知道当前的对应的链表节点的指针。所以map存的value可以直接设成对应的链表节点。
4. 当空间满的时候，知道了LRU的元素（表头），需要把这个元素从map中删除，所以list的节点需要知道对应的map的指针。
事后诸葛亮。。。
双头链表（doubly-linked lists）
1 record DoublyLinkedNode { 2 prev // A reference to the previous node 3 next // A reference to the next node 4 data // Data or a reference to data 5 } 6 record DoublyLinkedList { 7 DoublyLinkedNode firstNode // points to first node of list 8 DoublyLinkedNode lastNode // points to last node of list 9 }
1 function insertAfter(List list, Node node, Node newNode) 2 newNode.prev := node 3 newNode.next := node.next 4 if node.next == null 5 list.lastNode := newNode 6 else 7 node.next.prev := newNode 8 node.next := newNode
1 function insertBefore(List list, Node node, Node newNode) 2 newNode.prev := node.prev 3 newNode.next = node 4 if node.prev == null 5 list.firstNode := newNode 6 else 7 node.prev.next := newNode 8 node.prev := newNode
1 function insertBeginning(List list, Node newNode) 2 if list.firstNode == null 3 list.firstNode := newNode 4 list.lastNode := newNode 5 newNode.prev := null 6 newNode.next := null 7 else 8 insertBefore(list, list.firstNode, newNode)
1 function insertEnd(List list, Node newNode) 2 if list.lastNode == null 3 insertBeginning(list, newNode) 4 else 5 insertAfter(list, list.lastNode, newNode)
1 function remove(List list, Node node) 2 if node.prev == null 3 list.firstNode := node.next 4 else 5 node.prev.next := node.next 6 if node.next == null 7 list.lastNode := node.prev 8 else 9 node.next.prev := node.prev 10 destroy node
Circular doubly-linked lists
1 function remove(List list, Node node) 2 if node.next == node 3 list.lastNode := null 4 else 5 node.next.prev := node.prev 6 node.prev.next := node.next 7 if node == list.lastNode 8 list.lastNode := node.prev; 9 destroy node
Asymmetric doubly-linked list
同样是两个指针，next指针还是指向下一个，但是pre指针存的是自己的地址（指针的指针）。
特点：
1. 单向遍历；
2. 增删都是o(1)；
3. 只要节点存在，它的prev指针一定存在。
1 function insertBefore(Node node, Node newNode) 2 if node.prev == null 3 error "The node is not in a list" 4 newNode.prev := node.prev 5 atAddress(newNode.prev) := newNode 6 newNode.next := node 7 node.prev = addressOf(newNode.next)
1 function insertAfter(Node node, Node newNode) 2 newNode.next := node.next 3 if newNode.next != null 4 newNode.next.prev = addressOf(newNode.next) 5 node.next := newNode 6 newNode.prev := addressOf(node.next)
1 function remove(Node node) 2 atAddress(node.prev) := node.next 3 if node.next != null 4 node.next.prev = node.prev 5 destroy node
1 class LRUCache{ 2 public: 3 struct Data { 4 int val; 5 map<int, list<Data>::iterator >::iterator it; 6 }; 7 8 LRUCache(int capacity) { 9 this->capacity = capacity; 10 } 11 12 int get(int key) { 13 map<int, list<Data>::iterator >::iterator it = keyValues.find(key); 14 if (it == keyValues.end()) { 15 return -1; 16 } else { 17 int val = it->second->val; 18 data.erase(it->second); 19 Data d; 20 d.val = val; 21 d.it = it; 22 data.push_front(d); 23 keyValues[key] = data.begin(); 24 return val; 25 } 26 } 27 28 void set(int key, int value) { 29 map<int, list<Data>::iterator >::iterator it = keyValues.find(key); 30 if (it == keyValues.end()) { 31 if (data.size() >= capacity) { 32 keyValues.erase(data.back().it); //need to erase the map 33 data.pop_back(); 34 } 35 Data d; 36 d.val = value; 37 data.push_front(d); 38 keyValues[key] = data.begin(); 39 data.begin()->it = keyValues.find(key); 40 } else { 41 Data d; 42 d.val = value; 43 d.it = it; 44 data.erase(it->second); 45 data.push_front(d); 46 keyValues[key] = data.begin(); 47 } 48 } 49 50 private: 51 int capacity; 52 list<Data> data; 53 map<int, list<Data>::iterator > keyValues; 54 };