LRU算法，揭秘缓存机制中的“常青藤”！

前端

2023-12-03 04:41:35

LRU 算法：缓存机制中的常青藤

在计算机科学中，缓存机制至关重要，因为它可以快速高效地访问频繁使用的数据。LRU（最近最少使用）算法 是缓存机制中一种广受欢迎且强大的技术，它通过优先保留最近使用的数据项来优化缓存空间的利用率。

LRU 算法的核心思想

LRU 算法的核心思想是：最近使用的数据项更有可能再次被使用，而最久未使用的数据项则不太可能再次被使用。 因此，LRU 算法会将最近使用的数据项保留在缓存中，而将最久未使用的数据项淘汰出去。

LRU 算法的实现方式

LRU 算法通常有两种实现方式：

链表实现：
链表实现简单直观。它将数据项以链表的形式存储，其中最近使用的数据项位于链表头部，最久未使用的数据项位于链表尾部。当缓存空间已满时，链表尾部的最久未使用的数据项将被淘汰。

哈希表实现：
哈希表实现可以提高查找效率。它使用哈希表存储数据项及其对应的链表节点。当需要查找一个数据项时，哈希表可以快速定位到该数据项的节点。同样，当缓存空间已满时，链表尾部的最久未使用的数据项将被淘汰。

LRU 算法的应用场景

LRU 算法广泛应用于以下领域：

操作系统：管理进程内存分配
数据库：缓存查询结果
Web 服务器：缓存网页内容
浏览器：缓存网站数据

LeetCode 题解：理解 LRU 算法的实现

LeetCode 上的经典题型之一是设计 LRU 缓存算法。通过解决这道题，我们可以深入理解 LRU 算法的实现细节。

题目要求：
设计一个 LRU 缓存算法，支持以下操作：

get(key)：获取缓存中指定键的值，如果键不存在则返回 -1。
put(key, value)：将键值对 (key, value) 存储到缓存中。如果缓存已满，则需要淘汰最久未被使用的项目。

题解解析：
一种常见的 LRU 算法实现方式是将链表和哈希表结合使用：

使用哈希表存储键值对，以提高查找效率。
使用链表将数据项按照最近使用时间排序，并根据需要淘汰最久未被使用的项目。

关键代码示例：

class LRUCache:
    def __init__(self, capacity: int):
        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: int) -> int:
        if key in self.cache:
            node = self.cache[key]
            self.move_to_head(node)
            return node.value
        else:
            return -1

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            self.remove_node(self.cache[key])
        node = Node(key, value)
        self.add_to_head(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 move_to_head(self, node):
        self.remove_node(node)
        self.add_to_head(node)

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

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

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