为什么对 LRU 缓存使用双向链表和 HashMap 而不是 Deque？

Question

我在 LeetCode 上使用常规方法（双链表+哈希图）实现了 LRU 缓存问题的设计。对于那些不熟悉这个问题的人，这个实现看起来像这样：

我明白为什么要使用这种方法（两端快速移除/插入，中间快速访问）。我不明白的是，当人们可以简单地使用基于数组的双端队列（在 Java ArrayDeque 中，C++ 只是双端队列）时，为什么有人会同时使用 HashMap 和 LinkedList。这个双端队列允许在两端轻松插入/删除，并在中间快速访问，这正是 LRU 缓存所需要的。您还可以使用更少的空间，因为您不需要存储指向每个节点的指针。

为什么 LRU 缓存几乎被普遍设计（至少在大多数教程中）使用后一种方法而不是 Deque/ArrayDeque 方法？ HashMap/LinkedList 方法有什么好处吗？

Answer 1

当 LRU 缓存已满时，我们会丢弃 最近最少使用项。

如果我们要丢弃队列前面的项目，那么，我们必须确保最前面的项目是最长时间未使用的项目。

我们通过确保在每次使用时 将项目排到队列的后面来确保这一点。最前面的项目就是最长时间没有移到后面的项目。

为此，我们需要在每个put OR get 操作上维护队列：

• 当我们put缓存中的一个新项目时，它成为最近最近使用的项目，所以我们把它放在队列的后面。

  李>

• 当我们get一个已经在缓存中的项目时，它成为最近最近使用的项目，所以我们将它从当前位置移动到队列的最后。

将项目从中间移动到末尾不是双端队列操作，ArrayDeque 接口不支持。 ArrayDeque 使用的底层数据结构也没有有效地支持它。使用双向链表是因为它们确实有效地支持此操作。

Answer 2

LRU 缓存的目的是在O(1) 时间支持两个操作：get(key) 和put(key, value)，另外还有一个约束，即首先丢弃最近最少使用的键。通常，键是函数调用的参数，值是该调用的缓存输出。

无论您如何解决此问题，我们都同意您必须使用哈希图。您需要一个 hashmap 来将缓存中已经存在的键映射到 O(1) 中的值。

为了处理最近最少使用的键首先被丢弃的附加约束，您可以使用 LinkedList 或 ArrayDeque。但是，由于我们实际上不需要访问中间，所以 LinkedList 更好，因为您不需要调整大小。

编辑：

先生。 Timmermans 在他的回答中讨论了为什么 ArrayDeques 不能在 LRU cache 中使用，因为必须将元素从中间移动到末尾。话虽如此，这里是一个 LRU cache 的实现，它仅使用 deque 中的 appends 和 poplefts 成功提交到 leetcode。请注意，python 的 collections.deque 是作为双向链表实现的，但是我们只使用 collections.deque 中的操作，这些操作也是循环数组中的 O(1)，因此无论如何算法都保持不变。

from collections import deque

class LRUCache:

    def __init__(self, capacity: 'int'):
        self.capacity = capacity
        self.hashmap = {}
        self.deque = deque()

    def get(self, key: 'int') -> 'int':
        res = self.hashmap.get(key, [-1, 0])[0]
        if res != -1:
            self.put(key, res)
        return res

    def put(self, key: 'int', value: 'int') -> 'None':

        self.add(key, value)
        while len(self.hashmap) > self.capacity:
            self.remove()

    def add(self, key, value):
        if key in self.hashmap:
            self.hashmap[key][1] += 1
            self.hashmap[key][0] = value
        else:
            self.hashmap[key] = [value, 1]
        self.deque.append(key)

    def remove(self):
        k = self.deque.popleft()
        self.hashmap[k][1] -=1
        if self.hashmap[k][1] == 0:
            del self.hashmap[k]

我同意 Timmermans 先生的观点，即使用 LinkedList 方法更可取 - 但我想强调的是，使用 ArrayDeque 构建 LRU 缓存是可能的。

我和 Timmermans 先生之间的主要混淆是我们如何解释容量。我认为容量是指缓存最后一个 N 获取/放置请求，而 Timmermans 先生认为它是指缓存最后一个 N 唯一项。

上面的代码在put 中确实有一个循环，这会减慢代码的速度——但这只是为了让代码符合缓存最后一个N 唯一项。如果我们让代码缓存最后一个 N 请求，我们可以将循环替换为：

if len(self.deque) > self.capacity: self.remove()

这将使它与链表变体一样快。

无论maxsize 被解释为什么，上述方法仍可用作LRU 缓存——最近最少使用的元素首先被丢弃。

我只想强调以这种方式设计LRU 缓存是可能的。源就在那儿 - 尝试在 Leetcode 上提交！

Answer 3

双向链表是队列的实现。因为双向链表可以立即访问列表的开头和结尾，所以它们可以在 O(1) 的任一侧插入数据，也可以在 O(1) 的任一侧删除数据。因为双向链表可以在 O(1) 时间内在末尾插入数据并在 O(1) 时间内从前面删除数据，它们为队列提供了完美的底层数据结构。 Queeus 是项目列表，其中数据只能在末尾插入并从开头删除。

队列是抽象数据类型的一个例子，我们可以在底层使用数组来实现它们。现在，由于队列在末尾插入并从开头删除，因此数组仅与底层数据结构一样好。虽然数组在末尾插入是 O(1)，但从头开始删除是 O(N)。另一方面，双向链表在末尾插入和从开头删除都是 O(1)。这就是它非常适合用作队列的底层数据结构的原因。

Pyhon deque 使用链表作为其数据结构的一部分。这是它使用的那种链表。使用双向链表，deque 能够以恒定的 O(1) 性能从队列的两端插入或删除元素。 pyhton-deque