当前位置：首页 > news >正文

LRU 缓存的设计与实现

news 2025/11/9 6:53:03

一、LRU 缓存的核心诉求

二、数据结构选型与设计思路

1. 双向链表：维护访问顺序的 “时间轴”

2. 哈希表：实现 key 的 O (1) 寻址

3. 组合设计：“哈希表 + 双向链表” 的协同工作

三、代码实现

1. 类结构定义

2. get 方法实现：查询并更新访问顺序

3. put 方法实现：插入、更新与容量控制

四、复杂度与边界场景分析

1. 时间复杂度

2. 边界场景处理

五、测试验证与工程价值

六、总结

在高并发与大数据场景中，缓存是提升系统性能的关键手段，而 LRU（Least Recently Used，最近最少使用） 作为最经典的缓存淘汰策略之一，其设计与实现蕴含着深刻的工程智慧。本文将从底层原理出发，详细拆解 LRU 缓存的设计思路，并提供可直接落地的 C++ 实现。

一、LRU 缓存的核心诉求

LRU 策略的核心逻辑是：当缓存容量不足时，优先淘汰 “最久未被访问” 的缓存项。要实现这一策略，我们需要解决两个关键问题：

快速查询：给定 key，需在 O (1) 时间内判断是否存在并获取 value。
快速维护访问顺序：每次访问（get 或 put）后，需将缓存项标记为 “最近使用”；当容量不足时，需快速找到并淘汰 “最久未使用” 的项。

若仅用哈希表，虽能满足 “快速查询”，但无法高效维护访问顺序；若仅用链表，查询操作会退化为 O (n)，性能无法接受。因此，我们需要一种组合数据结构来突破这一困境。

二、数据结构选型与设计思路

1. 双向链表：维护访问顺序的 “时间轴”

使用双向链表存储缓存项，节点按 “最近使用” 到 “最久未使用” 的顺序排列：

链表头部：最近被访问的缓存项。
链表尾部：最久未被访问的缓存项（淘汰时的目标）。

双向链表的优势在于：

节点移动（标记为 “最近使用”）的时间复杂度为 O (1)（只需调整指针）。
淘汰操作（删除尾部节点）的时间复杂度为 O (1)。

2. 哈希表：实现 key 的 O (1) 寻址

使用 ** 哈希表（unordered_map）** 存储 key 到 “链表节点迭代器” 的映射，这样可以：

快速判断 key 是否存在（O (1) 时间）。
直接定位到对应的链表节点（O (1) 时间），从而避免遍历链表的开销。

3. 组合设计：“哈希表 + 双向链表” 的协同工作

哈希表的 value 是链表节点的迭代器，这样可以在 O (1) 时间内完成：

查询（get）：通过哈希表找到节点，返回 value 并将节点移到链表头部。
插入 / 更新（put）：若 key 存在则更新值并移到头部；若不存在则插入新节点到头部，若容量不足则删除尾部节点。

三、代码实现

1. 类结构定义

class LRUCache {
public:// 构造函数：初始化缓存容量LRUCache(int capacity) : _capacity(capacity) {}// 查询操作：O(1) 时间复杂度int get(int key);// 插入/更新操作：O(1) 时间复杂度void put(int key, int value);private:// 链表节点迭代器类型（指向存储 key-value 的双向链表节点）using ListIter = std::list<std::pair<int, int>>::iterator;std::unordered_map<int, ListIter> _hashMap;  // key -> 链表节点迭代器std::list<std::pair<int, int>> _lruList;     // 双向链表，维护访问顺序int _capacity;                               // 缓存最大容量
};

2. `get` 方法实现：查询并更新访问顺序

int LRUCache::get(int key) {auto it = _hashMap.find(key);if (it == _hashMap.end()) {return -1;  // key 不存在}// 将节点移到链表头部（标记为最近使用）_lruList.splice(_lruList.begin(), _lruList, it->second);return it->second->second;  // 返回 value
}

splice 是双向链表的核心操作，可在 O (1) 时间内将节点移动到任意位置（这里移到头部）。

3. `put` 方法实现：插入、更新与容量控制

void LRUCache::put(int key, int value) {auto it = _hashMap.find(key);if (it != _hashMap.end()) {// 情况1：key 已存在，更新 value 并标记为最近使用ListIter node = it->second;node->second = value;  // 更新 value_lruList.splice(_lruList.begin(), _lruList, node);} else {// 情况2：key 不存在，插入新节点// 若容量已满，淘汰最久未使用的节点（链表尾部）if (_lruList.size() == _capacity) {auto tail = _lruList.back();_hashMap.erase(tail.first);  // 从哈希表中删除_lruList.pop_back();         // 从链表中删除}// 插入新节点到链表头部_lruList.push_front({key, value});_hashMap[key] = _lruList.begin();  // 哈希表记录映射}
}

插入新节点前，若容量已满，需先删除链表尾部的 “最久未使用” 节点，并同步从哈希表中移除对应的 key。

四、复杂度与边界场景分析

1. 时间复杂度

get 操作：O (1)（哈希表查询 + 链表节点移动）。
put 操作：O (1)（哈希表插入 / 删除 + 链表节点移动 / 删除）。

这一复杂度满足了题目中 “O (1) 平均时间复杂度” 的要求。

2. 边界场景处理

空缓存 / 空 key：get 操作返回 -1。
容量为 1：每次插入都会淘汰之前的节点，保证缓存中始终只有最新的一个项。
重复 put 同一 key：会更新其 value 并将其标记为 “最近使用”。

五、测试验证与工程价值

我们通过一个典型场景验证实现的正确性：

int main() {LRUCache cache(2);  // 容量为 2 的 LRU 缓存cache.put(1, 1);cache.put(2, 2);cout << cache.get(1) << endl;  // 输出 1（1 被标记为最近使用）cache.put(3, 3);    // 容量已满，淘汰最久未使用的 2cout << cache.get(2) << endl;  // 输出 -1（2 已被淘汰）cache.put(4, 4);    // 容量已满，淘汰最久未使用的 1cout << cache.get(1) << endl;  // 输出 -1（1 已被淘汰）cout << cache.get(3) << endl;  // 输出 3（3 被标记为最近使用）cout << cache.get(4) << endl;  // 输出 4（4 被标记为最近使用）return 0;
}

输出结果与预期完全一致，证明了实现的正确性。