LRU（最近最少使用）：算法原理与Vue的实现

前端

2023-11-18 15:12:09

LRU算法是什么？

LRU算法（Least Recently Used，最近最少使用）是一种缓存淘汰策略，它基于一个简单的理念：最近最少使用的缓存数据最有可能被淘汰。LRU算法可以有效地管理缓存空间，确保最常使用的数据始终驻留在缓存中。

LRU算法的原理

LRU算法通过维护一个双向链表来实现，链表中的每个节点都代表一个缓存数据。链表的头部表示最近最常使用的缓存数据，链表的尾部表示最近最少使用的缓存数据。

当需要淘汰缓存数据时，LRU算法会从链表的尾部开始淘汰数据。如果链表中只有一个节点，则该节点会被直接淘汰。如果链表中有多个节点，则LRU算法会从尾部开始依次淘汰节点，直到缓存空间满足要求为止。

LRU算法的实现

LRU算法可以在各种编程语言中实现，下面我们以Python为例来实现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:
            node = self.cache[key]
            self.remove_node(node)
        else:
            node = Node(key, value)
            if self.capacity == 0:
                self.remove_last_node()
        self.add_node(node)

    def remove_node(self, node):
        if node == self.head:
            self.head = node.next
        else:
            node.prev.next = node.next
        if node == self.tail:
            self.tail = node.prev
        else:
            node.next.prev = node.prev
        del self.cache[node.key]

    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
        self.cache[node.key] = node

    def remove_last_node(self):
        node = self.tail
        self.remove_node(node)

class Node:

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