LRU算法：手把手教你面试中如何攻克代码题

前端

2023-06-09 10:16:18

LRU 算法：一种高效的缓存淘汰策略

在当今飞速发展的数字世界中，缓存扮演着至关重要的角色，它可以极大地提高系统性能和用户体验。在众多缓存淘汰策略中，LRU（最近最少使用）算法 脱颖而出，凭借其简单高效的机制广受应用。

LRU 算法简介

LRU 算法基于一个简单的原则：最近最少使用的缓存项将被淘汰 。当缓存已满，需要腾出空间时，LRU 算法会淘汰访问时间最长的缓存项，为新数据腾出空间。

LRU 算法的实现

LRU 算法的实现可以使用链表或哈希表。

链表实现

使用链表实现 LRU 算法时，缓存项存储在双向链表中。当访问缓存项时，其节点被移到链表头部。当缓存已满，链表尾部的节点被淘汰。

哈希表实现

使用哈希表实现 LRU 算法时，缓存项存储在哈希表中。哈希表中的键值对存储缓存项的访问时间。当缓存已满，哈希表中访问时间最长的缓存项被淘汰。

LRU 算法的优点

简单高效： LRU 算法易于理解和实现。
性能优异： LRU 算法可以有效淘汰不常用的缓存项，从而提高缓存命中率。
广泛应用： LRU 算法被广泛应用于各种系统中，例如操作系统、数据库和 Web 服务器。

面试中的手撕代码

在面试中，手撕代码是考察应聘者编程能力的重要方式。LRU 算法是面试中常见的代码题，它可以考察应聘者的算法设计能力和编程实现能力。

示例代码

class LRUCache:

    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}
        self.head = None
        self.tail = None

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

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

    def add_node(self, node):
        if self.head is None:
            self.head = node
            self.tail = node
        else:
            node.next = self.head
            self.head.prev = node
            self.head = node

    def remove_node(self, node):
        if node.prev is not None:
            node.prev.next = node.next
        else:
            self.head = node.next
        if node.next is not None:
            node.next.prev = node.prev
        else:
            self.tail = node.prev

class Node:

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