【每日一题】Leetcode 146

146. LRU缓存机制

运用你所掌握的数据结构，设计和实现一个 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

解题思路

参考精选题解，键值对的操作必然是要用到哈希表的，关于如何记录数据的最近访问状态，有两个想法：

1. 用队列，刚被push的键值一定是在队尾。但是刚刚访问的一个键很可能是在队中的，常数时间内无法把它提到队尾去；
2. 用老化机制，为所有的键值对再设置一个变量记录它们在cache中已经存在的回合数。每进行push或者get，其他键对映的该变量就要加一；当cache不足时挑选老化指数最大的键值对pop掉。这样的话，仍然会涉及到遍历问题，O(1)内无法完成。

目前能满足常数复杂度的只有哈希表查找，其余的会使得复杂度不满足条件。python中倒是有一个非常鸡贼的做法，用collections.OrderedDict。但是如果你真的在面试时这么写了，等着被面试官问OrderedDict的底层实现方式吧——兜兜转转还是会回到本题的考点：双向链表+哈希表。

这里的双向链表代替了设想1里面的队列，它在移动中间节点的时候只需要常数复杂度就能完成。

确认了需要用到的数据结构之后，实现的时候需要注意细节。哈希表是存键+链表节点，节点里包含键+值+前后指针。上代码：

class ListNode:
    def __init__(self, key = None, value = None):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache:

    def __init__(self, capacity: int):
        self.capacity = capacity
        self.hashmap = {}
        self.head = ListNode()
        self.tail = ListNode()
        self.head.next = self.tail
        self.tail.prev = self.head

    def insert_tail(self, key: int):
        node = self.hashmap[key]
        node.prev.next = node.next
        node.next.prev = node.prev

        node.prev = self.tail.prev
        node.next = self.tail
        self.tail.prev.next = node
        self.tail.prev = node

    def get(self, key: int) -> int:
        if key in self.hashmap:
            self.insert_tail(key)
        res = self.hashmap.get(key, -1)
        return res if res == -1 else res.value

    def put(self, key: int, value: int) -> None:
        if key in self.hashmap:
            self.hashmap[key].value = value
            self.insert_tail(key)
        else:
            if len(self.hashmap) == self.capacity:
                self.hashmap.pop(self.head.next.key)
                self.head.next = self.head.next.next
                self.head.next.prev = self.head
            new = ListNode(key, value)
            self.hashmap[key] = new
            new.prev = self.tail.prev
            new.next = self.tail
            new.prev.next = new
            self.tail.prev = new

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

一个小注释，hashmap.get(key, -1)表示如果hashmap中有key，返回对映值，否则返回-1.