Leetcode 146.LRU緩存機制（LRU Cache）

Leetcode 146.LRU緩存機制

1 題目描述（Leetcode題目鏈接）

  運用你所掌握的數據結構，設計和實現一個 LRU (最近最少使用) 緩存機制。它應該支持以下操作： 獲取數據 get 和 寫入數據 put 。

獲取數據 get(key) - 如果密鑰 (key) 存在於緩存中，則獲取密鑰的值（總是正數），否則返回 -1。
寫入數據 put(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

2 題解

  我們可以使用隊列來實現這個次序關係，其中隊頭爲最久未使用的，隊尾表示最近使用過的：

• 當get或put時，如果key已經在隊列中，則將key移動到隊列末尾
• 當插入一個新值時，如果容量已滿，則彈出隊頭，將新值插入到末尾，否則直接將新值插入到末尾。

問題就在於，如果在$O(1)$的時間複雜度把隊列中間的值移動到末尾，因此我們可以使用雙向鏈表+字典來實現，字典的$key$就是要插入的$key$，其對應的$value$就是鏈表節點，這樣我們就可以立刻找到需要移動的鏈表節點。詳見代碼註釋。

class Listnode:
    def __init__(self, key, val):
        self.key = key
        self.val = val
        self.pre = None
        self.next = None

class LRUCache:

    def __init__(self, capacity: int):
        self.cache = {}
        # head是鏈表頭節點
        self.head = Listnode(None, None)
        # end是鏈表尾結點        
        self.end = Listnode(None, None)         
        self.head.next = self.end
        self.end.pre = self.head
        self.capacity = capacity

    def get(self, key: int) -> int:
        # 如果key在cache中，則將key對應的節點移動到鏈表末尾
        if key in self.cache:           
            self.pick(key)
            self.insert_end(key)
            return self.cache[key].val
        return -1

    def put(self, key: int, value: int) -> None:
        # 如果key在cache中，則將key對應的節點移動到鏈表末尾，並更新值
        if key in self.cache:           
            self.pick(key)
            self.insert_end(key)
            self.cache[key].val = value
        else:
            # 如果key不在cache中，並且容量未到最大值，則新建節點並插入鏈表末尾
            if len(self.cache) < self.capacity:        
                self.cache[key] = Listnode(key, value)
                self.insert_end(key)
            else:
                # 容量到了最大值，就把鏈表第一個節點變成新值，然後插入鏈表末尾
                node = self.head.next                   
                self.cache.pop(node.key)
                node.key, node.val = key, value
                self.cache[key] = node
                self.pick(key)
                self.insert_end(key)          

    # 將key對應的節點從鏈表中摘出來   
    def pick(self, key):
        self.cache[key].pre.next = self.cache[key].next
        self.cache[key].next.pre = self.cache[key].pre

    # 將key對應的節點插入到鏈表末尾 
    def insert_end(self, key): 
        self.cache[key].next = self.end
        self.cache[key].pre = self.end.pre
        self.end.pre.next = self.cache[key]
        self.end.pre = self.cache[key]
        


# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)