Leetcode：LRUCache四个版本实现

题目

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.

链接：https://oj.leetcode.com/problems/lru-cache/

分析

1：维护最近最少（LRU）使用的cache

　　1）使用count计数，每次操作cache时（get、set），该cache的count置0，其余cache的count加1，count最大的为最近最少使用的cache

2）使用链表，每次操作cache时（get、set），将该cache移动至链表头，链表尾的cache为最近最少使用的cache

2：快速查找cache

　　1）使用stl::unordered_map存储cache地址（内部hashTable）

版本一

使用std::list维护LRU，链表中存储cache实际空间。

Runtime: 248ms。

 #include <list>
 #include <unordered_map>

 struct KeyValue {
     KeyValue(int pKey, int pValue):key(pKey), value(pValue) {};
     int key;
     int value;
 };

 class LRUCache{
 public:
     LRUCache(int capacity):_capacity(capacity) {};

     int get(int key);
     void set(int key, int value);

 private:
     std::unordered_map<int, std::list<KeyValue>::iterator> keyToNodeItr;
     std::list<KeyValue> lru;

     int _capacity;
 };

 void LRUCache::set(int key, int value) {
     auto itr = keyToNodeItr.find(key);
     if (itr != keyToNodeItr.end()) { // set value
         itr->second->value = value;
         KeyValue tmp(itr->second->key, itr->second->value);
         keyToNodeItr.erase(itr->second->key);
         lru.erase(itr->second);
         lru.push_front(tmp);
     } else { // insert value
         if (lru.size() != _capacity) {
             lru.push_front(KeyValue(key, value));
         } else {
             // pop back lru
             if (lru.size() != ) {
                 keyToNodeItr.erase((lru.rbegin())->key);
                 lru.pop_back();
             }
             lru.push_front(KeyValue(key, value));
         }
     }

     keyToNodeItr.insert(std::pair<int, std::list<KeyValue>::iterator>(key, lru.begin()));
 }

 int LRUCache::get(int key) {
     auto itr = keyToNodeItr.find(key);
     if (itr != keyToNodeItr.end()) {
         int value = itr->second->value;

         KeyValue tmp(itr->second->key, itr->second->value);
         keyToNodeItr.erase(itr->second->key);
         lru.erase(itr->second);
         lru.push_front(tmp);
         keyToNodeItr.insert(std::pair<int, std::list<KeyValue>::iterator>(key, lru.begin()));

         return value;
     }
     return -;
 }

因为链表中存储的为cache的实际空间，因此当需要改变cache的位置时，链表及map都需要改变，开销较大。

版本二

使用std::list维护LRU，链表中存储cache的指针。

Runtime：186ms。

 #include <list>
 #include <unordered_map>

 struct KeyValue {
     KeyValue(int pKey, int pValue):key(pKey), value(pValue) {};
     int key;
     int value;
 };

 class LRUCache{
 public:
     LRUCache(int capacity):_capacity(capacity) {};

     int get(int key);
     void set(int key, int value);

     ~LRUCache();

 private:
     std::unordered_map<int, std::list<KeyValue*>::iterator> keyToNodeItr;
     std::list<KeyValue*> lru;

     int _capacity;
 };

 LRUCache::~LRUCache() {
     for (auto itr = lru.begin(); itr != lru.end(); ++itr) {
         delete *itr;
     }
 }

 void LRUCache::set(int key, int value) {
     auto itr = keyToNodeItr.find(key);
     if (itr != keyToNodeItr.end()) { // set value
         KeyValue* tmp = *(itr->second);
         tmp->value = value;
         lru.erase(itr->second);
         lru.push_front(tmp);
         itr->second = lru.begin(); // avoid invalid iterator
     } else { // insert value
         if (lru.size() == _capacity) { // pop back lru
             KeyValue* tmp = *(lru.rbegin());
             keyToNodeItr.erase(tmp->key);
             delete tmp;
             lru.pop_back();
         }
         lru.push_front(new KeyValue(key, value));
         keyToNodeItr.insert(std::pair<int, std::list<KeyValue*>::iterator>(key, lru.begin()));
     }
 }

 int LRUCache::get(int key) {
     auto itr = keyToNodeItr.find(key);
     if (itr != keyToNodeItr.end()) {
         KeyValue* kvPtr = *(itr->second);
         lru.erase(itr->second);
         lru.push_front(kvPtr);
         itr->second = lru.begin();
         return kvPtr->value;
     }
     return -;
 }

需要注意的问题是map中存储的为list的迭代器，因此map中仍需要重新设置key到迭代器的映射，避免迭代器失效。

版本三

似乎std::list太笨重了，so实现轻量级双链表代替std::list。

Runtime: 77ms。

 struct BiListNode {
     BiListNode() {};
     BiListNode(int key, int value):key(key), value(value) {};
     int key;
     int value;
     BiListNode* pre;
     BiListNode* next;
 };

 class BiList {
 public:
     BiList():_count() {
         _head = new BiListNode();
         _head->pre = _head;
         _head->next = _head;
     }

     void push_front(BiListNode* pNode);

     void move_front(BiListNode* pNode);

     BiListNode* begin() {
         return _head->next;
     }

     BiListNode* rbegin() {
         return _head->pre;
     }

     void pop_back();

     int size() { return _count; }

     ~BiList();

 private:
     BiListNode* _head;
     int _count;
 };

 void BiList::push_front(BiListNode* pNode) {
     pNode->next = _head->next;
     pNode->pre = _head;
     _head->next->pre = pNode;
     _head->next = pNode;
     if (_head->pre == _head) {
         _head->pre = pNode;
     }
     ++_count;
 }

 void BiList::move_front(BiListNode* pNode) {
     if (pNode == _head->next) {
         return;
     }
     pNode->pre->next = pNode->next;
     pNode->next->pre = pNode->pre;

     pNode->next = _head->next;
     pNode->pre = _head;

     _head->next->pre = pNode;

     _head->next = pNode;
 }

 void BiList::pop_back() {
     BiListNode* tailPtr = _head->pre;
     tailPtr->pre->next = _head;
     _head->pre = tailPtr->pre;
     delete tailPtr;
     --_count;
 }

 BiList::~BiList() {
     for (BiListNode* itr = _head->next; itr != _head; itr = itr->next) {
         delete itr;
     }
     delete _head;
 }

 class LRUCache {
 public:
     LRUCache(int capacity):_capacity(capacity) {};

     int get(int key);

     void set(int key, int value);

 private:
     int _capacity;

     BiList biList;
     std::unordered_map<int, BiListNode*> keyToNodePtr;
 };

 int LRUCache::get(int key) {
     auto itr = keyToNodePtr.find(key);
     if (itr != keyToNodePtr.end()) {
         biList.move_front(itr->second);
         return itr->second->value;
     }
     return -;
 }

 void LRUCache::set(int key, int value) {
     auto itr = keyToNodePtr.find(key);
     if (itr != keyToNodePtr.end()) { // set value
         itr->second->value = value;
         biList.move_front(itr->second);
     } else { // insert
         if (biList.size() == _capacity) {
             keyToNodePtr.erase((biList.rbegin())->key);
             biList.pop_back();
         }
         biList.push_front(new BiListNode(key, value));
         keyToNodePtr.insert(std::pair<int, BiListNode*>(key, biList.begin()));
     }
 }

自己实现的双链表仅有80行代码，代码运行效率大大提高。

版本四

双链表都自己实现了，就死磕到底，再自己实现个开链哈希表吧。

Runtime：66ms。

 struct BiListNode {
     BiListNode() {};
     BiListNode(int key, int value):key(key), value(value) {};
     int key;
     int value;
     BiListNode* pre;
     BiListNode* next;
 };

 class BiList {
 public:
     BiList():_count() {
         _head = new BiListNode();
         _head->pre = _head;
         _head->next = _head;
     }

     void push_front(BiListNode* pNode);

     void move_front(BiListNode* pNode);

     BiListNode* begin() {
         return _head->next;
     }

     BiListNode* rbegin() {
         return _head->pre;
     }

     void pop_back();

     int size() { return _count; }

     ~BiList();

 private:
     BiListNode* _head;
     int _count;
 };

 void BiList::push_front(BiListNode* pNode) {
     pNode->next = _head->next;
     pNode->pre = _head;
     _head->next->pre = pNode;
     _head->next = pNode;
     if (_head->pre == _head) {
         _head->pre = pNode;
     }
     ++_count;
 }

 void BiList::move_front(BiListNode* pNode) {
     if (pNode == _head->next) {
         return;
     }
     pNode->pre->next = pNode->next;
     pNode->next->pre = pNode->pre;

     pNode->next = _head->next;
     pNode->pre = _head;

     _head->next->pre = pNode;

     _head->next = pNode;
 }

 void BiList::pop_back() {
     BiListNode* tailPtr = _head->pre;
     tailPtr->pre->next = _head;
     _head->pre = tailPtr->pre;
     delete tailPtr;
     --_count;
 }

 BiList::~BiList() {
     for (BiListNode* itr = _head->next; itr != _head; itr = itr->next) {
         delete itr;
     }
     delete _head;
 }

 struct hashNode {
     hashNode(int key, BiListNode* ptr):key(key), ptr(ptr), next(NULL) {};
     int key;
     BiListNode* ptr;
     hashNode* next;
 };

 class HashTable {
 public:
     HashTable(int capacity);

     hashNode* find(int key);

     void insert(int key, BiListNode* ptr);

     void erase(int key);

     ~HashTable();

 private:
     int _capacity;
     hashNode** hashArray;
 };

 HashTable::HashTable(int capacity):_capacity(capacity) {
     hashArray = new hashNode*[capacity];
     for (int i = ; i < _capacity; ++i) {
         hashArray[i] = NULL;
     }
 }

 hashNode* HashTable::find(int key) {
     for (hashNode* itr = hashArray[key % _capacity]; itr != NULL;
             itr = itr->next) {
         if (itr->key == key) {
             return itr;
         }
     }
     return NULL;
 }

 void HashTable::insert(int key, BiListNode* ptr) {
     hashNode* tmp = new hashNode(key, ptr);

     int relativeKey = key % _capacity;

     if (hashArray[relativeKey] == NULL) {
         hashArray[relativeKey] = tmp;
         return;
     }

     tmp->next = hashArray[relativeKey];
     hashArray[relativeKey] = tmp;
 }

 void HashTable::erase(int key) {
     for (hashNode* pre = hashArray[key % _capacity], *itr = pre;
             itr != NULL; pre = itr, itr = itr->next) {
         if (itr->key == key) {
             if (itr != pre)
                 pre->next = itr->next;
             else // head
                 hashArray[key % _capacity] = itr->next;

             delete itr;
         }
     }
 }

 HashTable::~HashTable() {
     for (int i = ; i < _capacity; ++i) {
         for (hashNode* itr = hashArray[i]; itr != NULL;) {
             hashNode* tmp = itr;
             itr = itr->next;
             delete tmp;
         }
     }
     delete [] hashArray;
 }

 class LRUCache {
 public:
     LRUCache(int capacity):_capacity(capacity) {
         hashTable = new HashTable();
     };

     int get(int key);

     void set(int key, int value);

     ~LRUCache() { delete hashTable; }

 private:
     int _capacity;
     BiList bilist;
     HashTable* hashTable;
 };

 int LRUCache::get(int key) {
     hashNode* tmp = hashTable->find(key);
     if (tmp != NULL) {
         bilist.move_front(tmp->ptr);
         return tmp->ptr->value;
     }
     return -;
 }

 void LRUCache::set(int key, int value) {
     hashNode* tmp = hashTable->find(key);
     if (tmp != NULL) { // set
         bilist.move_front(tmp->ptr);
         tmp->ptr->value = value;
         return;
     }

     // insert
     if (bilist.size() == _capacity) {
         hashTable->erase((bilist.rbegin())->key);
         bilist.pop_back();
     }

     bilist.push_front(new BiListNode(key, value));
     hashTable->insert(key, bilist.begin());
 }

开链哈希表72行代码