LRU缓存的实现思路和代码演示

2023-11-05 18:48:51

LRU缓存概述

LRU(Least Recently Used)缓存是一种常用的缓存淘汰策略，它基于“最近最少使用”的原则，将最近最少使用的缓存项淘汰出缓存，以腾出空间给新数据。LRU缓存常用于操作系统、数据库和Web服务器等场景中，以提高系统性能和减少内存使用。

LRU缓存的实现思路

LRU缓存的实现思路可以总结为以下几个步骤：

初始化缓存： 创建一定大小的缓存空间，并使用某种数据结构（如链表或哈希表）来存储缓存项。
添加缓存项： 当需要将新的缓存项添加到缓存中时，先检查缓存中是否存在该缓存项。如果存在，则更新其使用时间戳；如果不存在，则将该缓存项添加到缓存中，并将其使用时间戳设置为当前时间。
删除缓存项： 当缓存已满时，需要删除某个缓存项以腾出空间。根据LRU策略，需要删除最近最少使用的缓存项。通常有两种方法可以确定最近最少使用的缓存项：
- 使用链表实现： 在链表中，最近最少使用的缓存项位于链表的头部，而最近最常使用的缓存项位于链表的尾部。因此，可以通过删除链表头部的缓存项来淘汰最近最少使用的缓存项。
- 使用哈希表实现： 在哈希表中，每个缓存项都有一个使用时间戳，我们可以通过比较缓存项的使用时间戳来确定最近最少使用的缓存项。
更新缓存项的使用时间戳： 当某个缓存项被访问时，需要更新其使用时间戳，以便将其标记为最近使用过的缓存项。

LRU缓存的代码实现

下面提供两种实现LRU缓存的数据结构：链表实现和哈希表实现。

链表实现LRU缓存

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

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

    def get(self, key):
        if key in self.cache:
            node = self.cache[key]
            self._remove_node(node)
            self._add_node_to_tail(node)
            return node.value
        else:
            return None

    def put(self, key, value):
        if key in self.cache:
            node = self.cache[key]
            self._remove_node(node)
            node.value = value
            self._add_node_to_tail(node)
        else:
            node = Node(key, value)
            self.cache[key] = node
            self._add_node_to_tail(node)
            self.size += 1
            if self.size > self.capacity:
                node = self.head.next
                self._remove_node(node)
                del self.cache[node.key]
                self.size -= 1

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

    def _add_node_to_tail(self, node):
        node.next = self.tail
        node.prev = self.tail.prev
        self.tail.prev = node
        node.prev.next = node

哈希表实现LRU缓存

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.size = 0
        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 in self.cache:
            node = self.cache[key]
            self._remove_node(node)
            self._add_node_to_tail(node)
            return node.value
        else:
            return None

    def put(self, key, value):
        if key in self.cache:
            node = self.cache[key]
            self._remove_node(node)
            node.value = value
            self._add_node_to_tail(node)
        else:
            node = Node(key, value)
            self.cache[key] = node
            self._add_node_to_tail(node)
            self.size += 1
            if self.size > self.capacity:
                node = self.head.next
                self._remove_node(node)
                del self.cache[node.key]
                self.size -= 1

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

    def _add_node_to_tail(self, node):
        node.next = self.tail
        node.prev = self.tail.prev
        self.tail.prev = node
        node.prev.next = node