极简实现系列之如何利用三行代码搞定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

    def get(self, key):
        node = self.hash_table.get(key)
        if node is not None:
            self.move_to_head(node)
            return node.value
        else:
            return None

    def put(self, key, value):
        node = Node(key, value)
        self.hash_table[key] = node
        self.add_to_head(node)
        self.size += 1
        if self.size > self.capacity:
            node = self.remove_from_tail()
            del self.hash_table[node.key]
            self.size -= 1

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

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

    def remove_from_tail(self):
        node = self.tail.prev
        node.prev.next = self.tail
        self.tail.prev = node.prev
        return node

使用示例

cache = LRUCache(3)

cache.put(1, 10)
cache.put(2, 20)
cache.put(3, 30)

print(cache.get(1))  # 输出：10
cache.put(4, 40)

print(cache.get(2))  # 输出：None
print(cache.get(3))  # 输出：30
print(cache.get(4))  # 输出：40

总结

在这篇文章中，我们介绍了LRU算法的原理和实现，并给出了使用示例。LRU算法是一种非常重要的缓存算法，它可以帮助我们优化内存的使用，提高程序的性能。希望这篇文章能对您有所帮助。