leetcode_146_LRU缓存机制

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

解题

LRU规则

• 读取，如果key存在于缓存中，读取对应的value，并将改key设为最新处理的数据
• 写入
  • 读取，如果key存在于缓存中，覆盖写入对应的value，并将key设为最新处理的数据
  • 如果key不存在于缓存中，将该key-value添加至缓存，设为最新的数据
    • 如果此时总的数据量大于最大缓存容量，删除最旧的数据

使用双向链表表示缓存，其节点包括前向后向指针和key-value

使用字典保存节点信息，其key为节点的key，其value为整个节点，便于O(1)定位节点

首先建立额外的两个头尾节点便于操作

越靠近头节点的节点表示为越新的数据

class DLinkedNode:
    def __init__(self, key=0, value=0):
        self.key = key
        self.value = value
        self.pre = None
        self.next = None


class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.size = 0   # 现有数据数
        self.cache = {}
        self.head = DLinkedNode()
        self.tail = DLinkedNode()
        self.head.next = self.tail
        self.tail.pre = self.head

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self.move2head(node)
        return node.value

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            node = self.cache[key]
            node.value = value
            self.move2head(node)
        else:
            node = DLinkedNode(key, value)
            self.add2head(node)
            self.cache[key] = node
            self.size += 1
            # 如果大于最大容量，删除最旧数据
            if self.size > self.capacity:
                removed_node = self.remove_tail()
                self.cache.pop(removed_node.key)
                self.size -= 1

    # 将节点移动至头节点后一位位置，表示为最新操作数据
    def move2head(self, node):
        self.remove(node)
        self.add2head(node)

    # 删除节点
    def remove(self, node):
        node.pre.next = node.next
        node.next.pre = node.pre

    # 头节点后添加节点
    def add2head(self, node):
        self.head.next.pre = node
        node.next = self.head.next
        node.pre = self.head
        self.head.next = node

    # 删除尾部的前一个节点，表示为删除最旧操作数据
    def remove_tail(self):
        node = self.tail.pre
        self.remove(node)
        return node