146 LRU缓存-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_33524950/article/details/137481851

本文介绍了使用双向链表实现LRU缓存的数据结构，包括`DLinkedList`类的初始化、`get`和`put`方法，以及操作模块化的`remove`和`movetoHead`函数。关键特性是链表内存储key-value对，并利用虚拟头尾节点进行容量控制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

class DLinkedList:

    def __init__(self, key = 0, val = 0):
        self.prev = None
        self.next = None
        self.val = val
        self.key = key

class LRUCache:

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

    def get(self, key: int) -> int:
        if key in self.cache:
            node = self.cache[key]
            self.remove(node)
            self.movetoHead(node)
            return self.cache[key].val
        
        return -1


    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            node = self.cache[key]
            node.val = value
            self.remove(node)
            self.movetoHead(node)
        else:

            if self.capacity == 0:
                del self.cache[self.tail.prev.key]
                self.remove(self.tail.prev)
                self.capacity += 1

            node = DLinkedList(key,value)
            self.cache[key] = node
            self.capacity -= 1
            self.movetoHead(node)

            
    
    def movetoHead(self, node):
        tmp = self.head.next
        self.head.next = node
        node.prev = self.head
        node.next = tmp
        tmp.prev = node

    def remove(self, node):
        prev = node.prev
        next = node.next
        prev.next = next
        next.prev = prev

重点：

操作模块化（remove, movetoHead)；

双向链表，链表内保存key - value；

虚拟头尾节点。