LRU缓存：使用双向链表优化缓存性能

2024-02-07 07:14:49

1. 概述：LRU 缓存的基本原理

LRU 缓存（Least Recently Used Cache）是一种常用的缓存策略，它通过跟踪数据项的最近使用时间来决定哪些数据项应该被缓存。当缓存已满时，LRU 缓存会淘汰最近最少使用的数据项，为新数据项腾出空间。

LRU 缓存的优点在于，它可以有效地提高数据的访问速度。对于经常被访问的数据项，LRU 缓存可以将它们保存在缓存中，从而减少对底层存储介质的访问次数。对于不经常被访问的数据项，LRU 缓存会将它们淘汰出缓存，以腾出空间给更常用的数据项。

2. 实现：双向链表在 LRU 缓存中的应用

LRU 缓存的实现有多种方法，其中一种常用的方法是使用双向链表。双向链表是一种特殊的链表结构，它除了具有普通链表的特性之外，还允许从链表的任意一个节点开始，向前或向后遍历链表。

在 LRU 缓存中，我们可以使用双向链表来存储数据项。当数据项被访问时，我们会将其移动到链表的头部，以表示它最近被使用了。当缓存已满时，我们会从链表的尾部删除最近最少使用的数据项。

使用双向链表来实现 LRU 缓存，可以有效地降低删除操作的时间复杂度。在普通链表中，删除一个节点需要 O(n) 的时间复杂度，因为我们需要遍历整个链表才能找到要删除的节点。但在双向链表中，我们可以直接从链表的尾部删除节点，时间复杂度为 O(1)。

3. 代码示例：使用 Python 实现 LRU 缓存

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

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}
        self.head = Node(None, None)
        self.tail = Node(None, None)
        self.head.next = self.tail
        self.tail.prev = self.head

    def get(self, key):
        if key not in self.cache:
            return None
        node = self.cache[key]
        self.remove_node(node)
        self.add_node(node)
        return node.value

    def put(self, key, value):
        if key in self.cache:
            self.remove_node(self.cache[key])
        node = Node(key, value)
        self.add_node(node)
        self.cache[key] = node
        if len(self.cache) > self.capacity:
            del self.cache[self.tail.prev.key]
            self.remove_node(self.tail.prev)

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

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