LeetCode 算法：LRU 缓存 c++

2024-06-23 15:12
文章标签 leetcode 算法 c++ 缓存 lru

本文主要是介绍LeetCode 算法：LRU 缓存 c++，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

原题链接🔗：
难度：中等⭐️⭐️

题目

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。

实现 LRUCache 类：

  • LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
  • int get(int key)如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
  • void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例：

输入
[“LRUCache”, “put”, “put”, “get”, “put”, “get”, “put”, “get”, “get”, “get”]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4

提示：

  • 1 <= capacity <= 3000
  • 0 <= key <= 10000
  • 0 <= value <= 105
  • 最多调用 2 * 105 次 get 和 put

题解

  1. 解题思路：

LeetCode 上的 LRU 缓存问题（题目编号 146）要求我们实现一个 LRU 缓存类，该类支持两种操作：get 和
put。以下是解决这个问题的一般思路：

  • 理解问题：
    • get(key): 从缓存中获取键对应的值（如果存在）。缓存中键的最近使用时间应该被更新为当前时间。 -
    • put(key, value): 向缓存中插入或更新键和值。如果键已存在，则更新其值并更新其使用时间。如果键不存在，并且缓存已满，则需要先移除最久未使用的键。
  • 设计数据结构： 为了实现 LRU 缓存，我们需要两个主要的数据结构：
    • 哈希表：存储键到值的映射，以及键到双向链表中节点的引用，以便 O(1) 时间复杂度的访问。
    • 双向链表：存储缓存项的顺序，最近使用的项在头部，最久未使用的项在尾部。
  • 算法实现：
    • 初始化：创建一个固定大小的哈希表和空的双向链表。
    • get(key)： 检查键是否存在于哈希表中。 如果存在，移动该键关联的节点到双向链表的头部，表示最近使用。 返回键对应的值。 如果不存在，返回 -1。
    • put(key, value)：
      • 如果键已存在于哈希表中，更新其值，并将节点移动到双向链表的头部。
      • 如果键不存在：
        • 如果缓存未满，创建新节点，添加到双向链表的头部，并在哈希表中添加键到节点的映射。
        • 如果缓存已满，从双向链表尾部移除最久未使用的节点，并从哈希表中删除对应的键。
        • 然后，创建新节点，添加到双向链表的头部，并更新哈希表。
  1. 复杂度：时间复杂度O(1)，空间复杂度O(capacity)。
  2. c++ demo：
#include <iostream>
#include <unordered_map>
#include <list>class LRUCache {
private:int capacity;std::list<int> items; // 双向链表，存储键std::unordered_map<int, std::list<int>::iterator> cache; // 哈希表，存储键到链表迭代器的映射void moveToHead(int key) {items.splice(items.begin(), items, cache[key]); // 将节点移动到头部}void removeLeastRecent() {if (!items.empty()) {cache.erase(items.back()); // 从哈希表中删除items.pop_back(); // 从链表中删除}}public:LRUCache(int capacity) : capacity(capacity) {}int get(int key) {if (cache.find(key) != cache.end()) {moveToHead(key);return items.front();}else {return -1; // 键不存在}}void put(int key, int value) {if (cache.find(key) != cache.end()) {items.erase(cache[key]); // 从链表中删除旧节点cache.erase(key);}if (items.size() >= capacity) {removeLeastRecent(); // 检查是否需要淘汰}items.push_front(key); // 添加新节点到头部cache[key] = items.begin(); // 更新哈希表}
};int main() {LRUCache cache(2);cache.put(1, 1);std::cout << "Get 1: " << cache.get(1) << std::endl; // 返回 1cache.put(2, 2);std::cout << "Get 2: " << cache.get(2) << std::endl; // 返回 2cache.put(3, 3); // 淘汰键 1 使用 putstd::cout << "Get 1: " << cache.get(1) << std::endl; // 返回 -1 (未找到)std::cout << "Get 3: " << cache.get(3) << std::endl; // 返回 3cache.put(4, 4); // 淘汰键 2 使用 putstd::cout << "Get 2: " << cache.get(2) << std::endl; // 返回 -1 (未找到)cache.put(2, 6); // 重新添加键 2std::cout << "Get 2: " << cache.get(2) << std::endl; // 返回 6return 0;
}
  • 输出结果：

Get 1: 1
Get 2: 2
Get 1: -1
Get 3: 3
Get 2: -1
Get 2: 2

LRU 缓存

LRU（Least Recently Used）缓存是一种常用的缓存淘汰策略，它基于一个原则：如果数据最近被访问过，那么将来被访问的几率也更高。LRU 缓存通常用于操作系统、数据库、Web 服务器等场景，以减少内存或存储的使用，同时保持最常访问的数据可用。

LRU 缓存的实现

实现 LRU 缓存的一种常见方法是使用哈希表和双向链表。哈希表提供了 O(1) 的访问时间复杂度，而双向链表则允许我们以 O(1) 的时间复杂度进行数据的添加和删除操作。

数据结构
  1. 哈希表：存储键和对应节点的指针，以便快速访问。
  2. 双向链表：存储缓存中的项，最近使用的项在头部，最不常使用的项在尾部。
操作

  1. 访问缓存：

    • 检查键是否存在于哈希表中。
    • 如果存在，将对应的节点移动到双向链表的头部。
    • 如果不存在，根据需要从链表尾部移除一个节点（如果缓存已满），然后将新节点添加到头部。

  2. 添加到缓存：

    • 如果键已存在，更新其值，并将节点移动到链表头部。
    • 如果键不存在，创建新节点，添加到链表头部，并在哈希表中记录。

  3. 淘汰缓存：

    • 当缓存达到容量限制时，从链表尾部移除最不常使用的项，并从哈希表中删除相应的键。

示例代码

以下是使用 C++ 实现的 LRU 缓存的简单示例：

#include <iostream>
#include <list>
#include <unordered_map>class LRUCache {
private:int capacity;std::list<int> items; // 双向链表，存储键std::unordered_map<int, std::list<int>::iterator> cache; // 哈希表，存储键到链表迭代器的映射void moveToHead(int key) {items.splice(items.begin(), items, cache[key]); // 将节点移动到头部}void removeLeastRecent() {if (items.size() > capacity) {cache.erase(items.back()); // 从哈希表中删除items.pop_back(); // 从链表中删除}}public:LRUCache(int capacity) : capacity(capacity) {}int get(int key) {if (cache.find(key) != cache.end()) {moveToHead(key);return items.front();} else {return -1; // 键不存在}}void put(int key, int value) {if (cache.find(key) != cache.end()) {items.erase(cache[key]); // 从链表中删除旧节点} else {removeLeastRecent(); // 检查是否需要淘汰}items.push_front(key); // 添加新节点到头部cache[key] = items.begin(); // 更新哈希表}
};int main() {LRUCache cache(2);cache.put(1, 1);std::cout << cache.get(1) << std::endl; // 返回 1cache.put(2, 2);std::cout << cache.get(2) << std::endl; // 返回 2cache.put(3, 3); // 淘汰键 1std::cout << cache.get(1) << std::endl; // 返回 -1 (未找到)std::cout << cache.get(3) << std::endl; // 返回 3cache.put(4, 4); // 淘汰键 2std::cout << cache.get(2) << std::endl; // 返回 -1 (未找到)return 0;
}

这个示例展示了 LRU 缓存的基本操作，包括 get 和 put 方法。get 方法用于访问缓存中的项，而 put 方法用于添加或更新缓存中的项。如果缓存达到容量限制，put 方法还会淘汰最不常使用的项。

这篇关于LeetCode 算法：LRU 缓存 c++的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1087515。

相关文章

C++右移运算符的一个小坑及解决

C++右移运算符的一个小坑及解决

《C++右移运算符的一个小坑及解决》文章指出右移运算符处理负数时左侧补1导致死循环,与除法行为不同,强调需注意补码机制以正确统计二进制1的个数... 目录我遇到了这么一个www.chinasem.cn函数由此可以看到也很好理解总结我遇到了这么一个函数template<typename T>unsigned
阅读更多...
C++统计函数执行时间的最佳实践

C++统计函数执行时间的最佳实践

《C++统计函数执行时间的最佳实践》在软件开发过程中,性能分析是优化程序的重要环节,了解函数的执行时间分布对于识别性能瓶颈至关重要,本文将分享一个C++函数执行时间统计工具,希望对大家有所帮助... 目录前言工具特性核心设计1. 数据结构设计2. 单例模式管理器3. RAII自动计时使用方法基本用法高级用法
阅读更多...
深入解析C++ 中std::map内存管理

深入解析C++ 中std::map内存管理

《深入解析C++中std::map内存管理》文章详解C++std::map内存管理,指出clear()仅删除元素可能不释放底层内存,建议用swap()与空map交换以彻底释放,针对指针类型需手动de... 目录1️、基本清空std::map2️、使用 swap 彻底释放内存3️、map 中存储指针类型的对象
阅读更多...
使用Spring Cache本地缓存示例代码

使用Spring Cache本地缓存示例代码

《使用SpringCache本地缓存示例代码》缓存是提高应用程序性能的重要手段,通过将频繁访问的数据存储在内存中,可以减少数据库访问次数,从而加速数据读取,：本文主要介绍使用SpringCac... 目录一、Spring Cache简介核心特点：二、基础配置1. 添加依赖2. 启用缓存3. 缓存配置方案方案
阅读更多...
C++ STL-string类底层实现过程

C++ STL-string类底层实现过程

《C++STL-string类底层实现过程》本文实现了一个简易的string类,涵盖动态数组存储、深拷贝机制、迭代器支持、容量调整、字符串修改、运算符重载等功能,模拟标准string核心特性,重点强... 目录实现框架一、默认成员函数1.默认构造函数2.构造函数3.拷贝构造函数(重点)4.赋值运算符重载函数
阅读更多...
C++ vector越界问题的完整解决方案

C++ vector越界问题的完整解决方案

《C++vector越界问题的完整解决方案》在C++开发中,std::vector作为最常用的动态数组容器,其便捷性与性能优势使其成为处理可变长度数据的首选,然而,数组越界访问始终是威胁程序稳定性的... 目录引言一、vector越界的底层原理与危害1.1 越界访问的本质原因1.2 越界访问的实际危害二、基
阅读更多...
Java实现本地缓存的四种方法实现与对比

Java实现本地缓存的四种方法实现与对比

《Java实现本地缓存的四种方法实现与对比》本地缓存的优点就是速度非常快,没有网络消耗,本地缓存比如caffine,guavacache这些都是比较常用的,下面我们来看看这四种缓存的具体实现吧... 目录1、HashMap2、Guava Cache3、Caffeine4、Encache本地缓存比如 caff
阅读更多...
c++日志库log4cplus快速入门小结

c++日志库log4cplus快速入门小结

《c++日志库log4cplus快速入门小结》文章浏览阅读1.1w次，点赞9次，收藏44次。本文介绍Log4cplus，一种适用于C++的线程安全日志记录API，提供灵活的日志管理和配置控制。文章涵盖... 目录简介日志等级配置文件使用关于初始化使用示例总结参考资料简介log4j 用于Java，log4c
阅读更多...
Android 缓存日志Logcat导出与分析最佳实践

Android 缓存日志Logcat导出与分析最佳实践

《Android缓存日志Logcat导出与分析最佳实践》本文全面介绍AndroidLogcat缓存日志的导出与分析方法,涵盖按进程、缓冲区类型及日志级别过滤,自动化工具使用,常见问题解决方案和最佳实... 目录android 缓存日志（Logcat）导出与分析全攻略为什么要导出缓存日志？按需过滤导出1. 按
阅读更多...
C++归并排序代码实现示例代码

C++归并排序代码实现示例代码

《C++归并排序代码实现示例代码》归并排序将待排序数组分成两个子数组,分别对这两个子数组进行排序,然后将排序好的子数组合并,得到排序后的数组,：本文主要介绍C++归并排序代码实现的相关资料,需要的... 目录1 算法核心思想2 代码实现3 算法时间复杂度1 算法核心思想归并排序是一种高效的排序方式，需要用
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2