leetcode-146. LRU缓存机制

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。
实现 LRUCache 类：

LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

进阶：你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例：

输入
[“LRUCache”, “put”, “put”, “get”, “put”, “get”, “put”, “get”, “get”, “get”]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4

提示：

1 <= capacity <= 3000
0 <= key <= 3000
0 <= value <= 104
最多调用 3 * 104 次 get 和 put

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lru-cache
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。``

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

    # 因为get put操作都会将新更新的元素移动到末尾，保持最新的元素在末尾
    def move_node_to_tail(self, key) -> None:
        # 将node取出来  插入到尾结点之前，尾结点保存的就是最新更新的结点
        node = self.hashmap.get(key)
        # 先把node断开
        node.prev.next = node.next
        node.next.prev = node.prev
        # 再把node插入最新的位置，也就是尾结点前面
        node.next = self.tail
        node.prev = self.tail.prev
        self.tail.prev.next = node
        self.tail.prev = node

    def get(self, key: int) -> int:
        if key in self.hashmap:
            self.move_node_to_tail(key)  # 在当前hash表中存在，那么直接移动到更新位置
        result = self.hashmap.get(key, -1)  # 存在key返回value，不存在返回value
        if result == -1:
            return result
        return result.value

    def put(self, key: int, value: int) -> int:
        if key in self.hashmap:
            # 如果当前要插入的元素存在，那么更新并移动到更新位置即可
            self.hashmap[key].value = value
            self.move_node_to_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