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++实现链表元素的反转》反转链表是链表操作中一个经典的问题,也是面试中常见的考题,本文将从思路到实现一步步地讲解如何实现链表的反转,帮助初学者理解这一操作,我们将使用C++代码演示具体实现,同... 目录问题定义思路分析代码实现带头节点的链表代码讲解其他实现方式时间和空间复杂度分析总结问题定义给定
阅读更多...
C++初始化数组的几种常见方法(简单易懂)

C++初始化数组的几种常见方法(简单易懂)

《C++初始化数组的几种常见方法(简单易懂)》本文介绍了C++中数组的初始化方法,包括一维数组和二维数组的初始化,以及用new动态初始化数组,在C++11及以上版本中,还提供了使用std::array... 目录1、初始化一维数组1.1、使用列表初始化（推荐方式）1.2、初始化部分列表1.3、使用std::
阅读更多...
C++ Primer 多维数组的使用

C++ Primer 多维数组的使用

《C++Primer多维数组的使用》本文主要介绍了多维数组在C++语言中的定义、初始化、下标引用以及使用范围for语句处理多维数组的方法,具有一定的参考价值,感兴趣的可以了解一下... 目录多维数组多维数组的初始化多维数组的下标引用使用范围for语句处理多维数组指针和多维数组多维数组严格来说,C++语言没
阅读更多...
c++中std::placeholders的使用方法

c++中std::placeholders的使用方法

《c++中std::placeholders的使用方法》std::placeholders是C++标准库中的一个工具,用于在函数对象绑定时创建占位符,本文就来详细的介绍一下,具有一定的参考价值,感兴... 目录1. 基本概念2. 使用场景3. 示例示例 1：部分参数绑定示例 2：参数重排序4. 注意事项5.
阅读更多...
使用C++将处理后的信号保存为PNG和TIFF格式

使用C++将处理后的信号保存为PNG和TIFF格式

《使用C++将处理后的信号保存为PNG和TIFF格式》在信号处理领域,我们常常需要将处理结果以图像的形式保存下来,方便后续分析和展示,C++提供了多种库来处理图像数据,本文将介绍如何使用stb_ima... 目录1. PNG格式保存使用stb_imagephp_write库1.1 安装和包含库1.2 代码解
阅读更多...
C++实现封装的顺序表的操作与实践

C++实现封装的顺序表的操作与实践

《C++实现封装的顺序表的操作与实践》在程序设计中,顺序表是一种常见的线性数据结构,通常用于存储具有固定顺序的元素,与链表不同,顺序表中的元素是连续存储的,因此访问速度较快,但插入和删除操作的效率可能... 目录一、顺序表的基本概念二、顺序表类的设计1. 顺序表类的成员变量2. 构造函数和析构函数三、顺序表
阅读更多...
使用C++实现单链表的操作与实践

使用C++实现单链表的操作与实践

《使用C++实现单链表的操作与实践》在程序设计中,链表是一种常见的数据结构,特别是在动态数据管理、频繁插入和删除元素的场景中,链表相比于数组,具有更高的灵活性和高效性,尤其是在需要频繁修改数据结构的应... 目录一、单链表的基本概念二、单链表类的设计1. 节点的定义2. 链表的类定义三、单链表的操作实现四、
阅读更多...
MySQL 缓存机制与架构解析(最新推荐)

MySQL 缓存机制与架构解析(最新推荐)

《MySQL缓存机制与架构解析(最新推荐)》本文详细介绍了MySQL的缓存机制和整体架构,包括一级缓存（InnoDBBufferPool）和二级缓存（QueryCache）,文章还探讨了SQL... 目录一、mysql缓存机制概述二、MySQL整体架构三、SQL查询执行全流程四、MySQL 8.0为何移除查
阅读更多...
使用C/C++调用libcurl调试消息的方式

使用C/C++调用libcurl调试消息的方式

《使用C/C++调用libcurl调试消息的方式》在使用C/C++调用libcurl进行HTTP请求时,有时我们需要查看请求的/应答消息的内容（包括请求头和请求体）以方便调试,libcurl提供了多种... 目录1. libcurl 调试工具简介2. 输出请求消息使用 CURLOPT_VERBOSE使用 C
阅读更多...
C++实现获取本机MAC地址与IP地址

C++实现获取本机MAC地址与IP地址

《C++实现获取本机MAC地址与IP地址》这篇文章主要为大家详细介绍了C++实现获取本机MAC地址与IP地址的两种方式,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 实际工作中，项目上常常需要获取本机的IP地址和MAC地址，在此使用两种方案获取1.MFC中获取IP和MAC地址获取
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2