設計實現一個 LRU（最近最少使用）緩存數據結構

題目：LRU 緩存機制 設計和實現一個 LRU（最近最少使用）緩存數據結構，使它應該支持一下操作：get 和 put。 get(key) - 如果 key 存在於緩存中，則獲取 key 的 value（總是正數），否則返回 -1。 put(key,value) - 如果 key 不存在，請設置或插入 value。當緩存達到其容量時，它應該在插入新項目之前使最近最少使用的項目作廢。
參考答案：


進階:
你是否可以在 O(1) 時間複雜度內完成這兩種操作？


示例:

LRUCache cache = new LRUCache( 2 /* 緩存容量 */ );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 該操作會使得密鑰 2 作廢
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 該操作會使得密鑰 1 作廢
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

思路解析
這道題是讓我們實現一個 LRU 緩存器，LRU是Least Recently Used的簡寫，就是最近最少使用的意思。


這個緩存器主要有兩個成員函數，get和put。


其中 get 函數是通過輸入 key 來獲得 value，如果成功獲得後，這對 (key, value) 升至緩存器中最常用的位置（頂部），如果 key 不存在，則返回 -1 。


而 put 函數是插入一對新的 (key, value)，如果原緩存器中有該 key，則需要先刪除掉原有的，將新的插入到緩存器的頂部。如果不存在，則直接插入到頂部。


若加入新的值後緩存器超過了容量，則需要刪掉一個最不常用的值，也就是底部的值。


具體實現時我們需要三個私有變量，cap , l 和 m，其中 cap 是緩存器的容量大小，l 是保存緩存器內容的列表，m 是 HashMap，保存關鍵值 key 和緩存器各項的迭代器之間映射，方便我們以 O(1) 的時間內找到目標項。


然後我們再來看 get 和 put 如何實現。


其中，get 相對簡單些，我們在 m 中查找給定的key，若不存在直接返回 -1；如果存在則將此項移到頂部。


對於 put ，我們也是現在 m 中查找給定的 key，如果存在就刪掉原有項，並在頂部插入新來項，然後判斷是否溢出，若溢出則刪掉底部項(最不常用項)。


參考代碼
python版本的：

class LRUCache(object):
   def __init__(self, capacity):
   """
   :type capacity: int
   """
   self.cache = {}
   self.keys = []
   self.capacity = capacity
   
   def visit_key(self, key):
       if key in self.keys:
           self.keys.remove(key)
       self.keys.append(key)
   
   def elim_key(self):
       key = self.keys[0]
       self.keys = self.keys[1:]
       del self.cache[key]
       
   def get(self, key):
       """
       :type key: int
       :rtype: int
       """
       if not key in self.cache:
           return -1
       self.visit_key(key)
       return self.cache[key]
   
   def put(self, key, value):
       """
       :type key: int
       :type value: int
       :rtype: void
       """
       if not key in self.cache:
       if len(self.keys) == self.capacity:
       self.elim_key()
       self.cache[key] = value
       self.visit_key(key)
def main():
   s =
   [["put","put","get","put","get","put","get","get","get"],[[1,1],[2,2],[1],[3,3],[2],[
   4,4],[1],[3],[4]]]
   obj = LRUCache(2)
   l=[]
   for i,c in enumerate(s[0]):
       if(c == "get"):
           l.append(obj.get(s[1][i][0]))
       else:
           obj.put(s[1][i][0], s[1][i][1])
   print(l)
if __name__ == "__main__":
   main()

c++版本的：

class LRUCache{
   public:
       LRUCache(int capacity) {
           cap = capacity;
       }
       
       int get(int key) {
           auto it = m.find(key);
           if (it == m.end()) return -1;
           l.splice(l.begin(), l, it->second);
           return it->second->second;
       }
       
       void set(int key, int value) {
           auto it = m.find(key);
           if (it != m.end()) l.erase(it->second);
           l.push_front(make_pair(key, value));
           m[key] = l.begin();
           if (m.size() > cap) {
               int k = l.rbegin()->first;
               l.pop_back();
               m.erase(k);
           }
       }
   
private:
   int cap;
   list<pair<int, int>> l;
   unordered_map<int, list<pair<int, int>>::iterator> m;
};

Java代碼：

package question;
import java.util.*;
/**
* 哈希表加雙向鏈表。
*
* 每次新增節點時，往鏈表頭部放入。需要刪除時，刪除鏈表尾節點。
*
* get()和put()的時間複雜度均是O(1)。空間複雜度是O(n)，其中n爲緩存的鍵數。
*
* 執行用時：141ms，擊敗79.91%。消耗內存：55.7MB，擊敗96.89%。
*/
class LRUCache1 {
   private class Node {
       private int key;
       private int value;
       private Node pre;
       private Node next;
       public Node() {
       }
       public Node(int key, int value) {
           this.key = key;
           this.value = value;
       }
   }
   private Node dummyHead = new Node();
   private Node dummyTail = new Node();
   private int capacity;
   private int size;
   private HashMap<Integer, Node> hashMap = new HashMap<>();
   //將節點添加到虛擬頭節點之後
   private void add(Node node) {
       Node originHead = dummyHead.next;
       dummyHead.next = node;
       node.pre = dummyHead;
       node.next = originHead;
       originHead.pre = node;
   }
   //刪除某個節點
   private void del(Node node) {
       Node preNode = node.pre;
       Node nextNode = node.next;
       preNode.next = nextNode;
       nextNode.pre = preNode;
       node.pre = null;
       node.next = null;
   }
   public LRUCache1(int capacity) {
       dummyHead.next = dummyTail;
       dummyTail.pre = dummyHead;
       this.capacity = capacity;
       size = 0;
   }
   public int get(int key) {
       Node node = hashMap.get(key);
       if (null == node) {
           return -1;
       }
       del(node);
       add(node);
       return node.value;
   }
   public void put(int key, int value) {
       Node node = hashMap.get(key);
       if (null != node) {
           node.value = value;
           del(node);
           add(node);
       } else {
           if (size < capacity) {
               size++;
           } else {
               //刪除鏈表尾節點
               Node delNode = dummyTail.pre;
               hashMap.remove(delNode.key);
               del(delNode);
           }
           Node newNode = new Node(key, value);
           add(newNode);
           hashMap.put(key, newNode);
       }
   }
}

或

package question;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 自定義一個雷LRULinedHashMap繼承自LinkedHashMap，並重寫其removeEldestEntry方法。
*
* get()和put()的時間複雜度均是O(1)。空間複雜度是O(n)，其中n爲緩存的鍵數。
*
* 執行用時：144ms，擊敗74.73%。消耗內存：62.3MB，擊敗67.95%。
*/
public class LRUCache2 {
   private int capacity;
   private LRULinkedHashMap<Integer, Integer> lruLinkedHashMap = new LRULinkedHashMap<>();
   private class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {
       @Override
       protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
           if (size() > capacity) {
               return true;
           } else {
               return false;
           }
       }
   }
   public LRUCache2(int capacity) {
       this.capacity = capacity;
   }
   public int get(int key) {
       Integer value = lruLinkedHashMap.get(key);
       if (null == value) {
           return -1;
       }
       lruLinkedHashMap.remove(key);
       lruLinkedHashMap.put(key, value);
       return value;
   }
   public void put(int key, int value) {
       if (lruLinkedHashMap.containsKey(key)) {
           lruLinkedHashMap.remove(key);
       }
       lruLinkedHashMap.put(key, value);
   }
}