【算法】LRU缓存算法的C++实现

已于 2024-05-01 16:06:17 修改
阅读量6.1k 收藏 23
点赞数 19
文章标签： c++ 算法 leetcode
于 2024-03-09 16:10:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Conner7/article/details/136572016
版权

一、LRU简介

LRU(Least Resently Used，最近最久未使用)算法是一种缓存淘汰策略。

对于计算机来说，缓存容量是有限的，当缓存满了时就要用到LRU，对于很久没有用过的数据，我们可以将其判定为无用的数据，当新资源进入缓存或者用到了某个数据的时候，对应的资源可以判定为有用的数据，当缓存满了时我们应当优先淘汰无用的数据，而对于最近使用过的数据应当靠后淘汰，这就是LRU算法。

LRU算法也是面试时经常考察的算法题，见LeetCode146. LRU缓存，题目要求如下：

二、思路解析

在LRU缓存算法中，采用了一种有趣的数据结构——哈希链表，即HashMap+双向链表。这样一来，原本无序的哈希表就拥有了固定的排列顺序。

让我们以用户信息的需求为例，来演示一下LRU算法的基本思路：

1. 假设使用哈希链表来缓存用户信息，目前缓存了4个用户，这4个用户是按照被访问的时间顺序依次从链表右端插入的。

2. 如果这时业务方访问用户5，由于哈希链表中没有用户5的数据，需要从数据库中读取出来，插入到缓存中。此时，链表最右端是最新被访问的用户5，最左端是最近最少被访问的用户1。

3. 接下来，如果业务方访问用户2，哈希链表中已经存在用户2的数据，这时我们把用户2从它的前驱节点和后继节点之间移除，重新插入链表的最右端。此时，链表的最右端变成了最新被访问的用户2，最左端仍然是最近最少被访问的用户1。

4. 接下来，如果业务方请求修改用户4的信息。同样的道理，我们会把用户4从原来的位置移动到链表的最右侧，并把用户信息的值更新。这时，链表的最右端是最新被访问的用户4，最左端仍然是最近最少被访问的用户1。

5. 后来业务方又要访问用户6，用户6在缓存里没有，需要插入哈希链表中。假设这时缓存容量已经达到上限，必须先删除最近最少被访问的数据，那么位于哈希链表最左端的用户1就会被删除，然后再把用户6插入最右端的位置。

这就是LRU算法的基本思路。

三、具体代码

LeetCode的官方C++题解除了get()函数和put()函数外，还使用了四个函数。笔者重新整理了一下代码，只用再使用refresh()和remove()函数。

下面的代码以头部节点为最近使用的，尾部节点为最久未使用的。

首先自己定义一个双向链表，每个节点有key、value、prev指针、next指针4个属性。

class DListNode {
public:
    DListNode(): key(0), value(0), prev(nullptr), next(nullptr) {};
    DListNode(int _key, int _value): key(_key), value(_value), prev(nullptr), next(nullptr) {};
    
    int key, value;
    DListNode* prev;
    DListNode* next;
};

LRU缓存类有5个属性：存放key值和节点地址的哈希表cache、头节点head（假头）、尾节点tail（假尾）、当前大小、容量。

class LRUCache {
private:
    unordered_map<int, DListNode*> cache;
    DListNode* head;
    DListNode* tail;
    int size;
    int capacity;
}

LRUcache的初始化操作如下，为了在添加节点和删除节点的时候不需要检查相邻的节点是否存在，这里使用了伪头(dummyHead)和伪尾(dummyTail)，之后互相链接构成双向链表。

public:
    LRUCache(int _capacity): capacity(_capacity), size(0) {
        head = new DListNode();
        tail = new DListNode();
        head->next = tail;
        tail->prev = head;
    }

get()函数的逻辑：如果key在哈希表中不存在则返回-1；否则先定位并refresh该节点，再返回节点的value。

int get(int key) {
        if (!cache.count(key)) {    // count()返回被查找元素的个数，无即返回0
            return -1;
        }
        DListNode* node = cache[key];
        refresh(node);
        return node->value;
    }

put()函数的逻辑：如果key在哈希表中不存在，则先创建一个新节点，并添加进哈希表，然后refresh该节点并更新LRUcache的大小，如果LRUcache的大小超过容量，则remove双向链表的尾部节点，删除哈希表中的对应项，并释放相应内存；

而如果key在哈希表中存在，则先通过哈希表定位，修改value，然后refresh该节点。

void put(int key, int value) {
        if (!cache.count(key)) {
            DListNode* node = new DListNode(key, value);
            cache[key] = node;
            refresh(node);
            size++;
            if (size > capacity) {
                DListNode* removedNode = tail->prev;
                remove(removedNode);
                cache.erase(removedNode->key);
                delete removedNode;
                size--;
            }
        } else{
            DListNode* node = cache[key];
            node->value = value;
            refresh(node);
        }
    }

refresh()函数的逻辑：如果该节点在链表中，先remove该节点（判断是否处于链表中的逻辑在remove函数里），再把该节点移到头部。

void refresh(DListNode* node) {
        remove(node);
        node->prev = head;
        node->next = head->next;
        head->next->prev = node;
        head->next = node;
    }

remove()函数的逻辑：先判断该节点是否处于链表中，如果是则删除该节点。

void remove(DListNode* node) {
        if (node->next != nullptr) {
            node->prev->next = node->next;
            node->next->prev = node->prev;
        }
    }

综上，LeetCode146. LRU缓存 的题解如下：

//新的放头部，旧的放尾部

//定义一个双向链表，每个节点有key、value、prev指针、next指针4个属性
class DListNode {
public:
    DListNode(): key(0), value(0), prev(nullptr), next(nullptr) {};
    DListNode(int _key, int _value): key(_key), value(_value), prev(nullptr), next(nullptr) {};
    
    int key, value;
    DListNode* prev;
    DListNode* next;
};

class LRUCache {

//LRU缓存类有5个属性：存放key值和节点地址的哈希表cache、头节点head（假头）、尾节点tail（假尾）、当前大小、容量
private:
    unordered_map<int, DListNode*> cache;
    DListNode* head;
    DListNode* tail;
    int size;
    int capacity;

public:
    //初始化
    LRUCache(int _capacity): capacity(_capacity), size(0) {
        head = new DListNode();
        tail = new DListNode();
        head->next = tail;
        tail->prev = head;
    }
    
    //get函数的逻辑：如果key在哈希表中不存在则返回-1；否则先定位并refresh该节点，再返回节点的value
    int get(int key) {
        if (!cache.count(key)) {
            return -1;
        }
        DListNode* node = cache[key];
        refresh(node);
        return node->value;
    }
    
    //put函数的逻辑：如果key在哈希表中不存在，则先创建一个新节点，并添加进哈希表，然后refresh该节点并更新LRUcache的大小，
    //如果LRUcache的大小超过容量，则remove双向链表的尾部节点，删除哈希表中的对应项，并释放相应内存
    //如果key在哈希表中存在，则先通过哈希表定位，修改value，然后refresh该节点
    void put(int key, int value) {
        if (!cache.count(key)) {
            DListNode* node = new DListNode(key, value);
            cache[key] = node;
            refresh(node);
            size++;
            if (size > capacity) {
                DListNode* removedNode = tail->prev;
                remove(removedNode);
                cache.erase(removedNode->key);
                delete removedNode;
                size--;
            }
        } else{
            DListNode* node = cache[key];
            node->value = value;
            refresh(node);
        }
    }

    //refresh函数的逻辑：如果该节点在链表中，先remove该节点（判断是否处于链表中的逻辑在remove函数里），再把该节点移到头部
    void refresh(DListNode* node) {
        remove(node);
        node->prev = head;
        node->next = head->next;
        head->next->prev = node;
        head->next = node;
    }

    //remove函数的逻辑：先判断该节点是否处于链表中，如果是则删除该节点
    void remove(DListNode* node) {
        if (node->next != nullptr) {
            node->prev->next = node->next;
            node->next->prev = node->prev;
        }
    }
};

四、ACM代码

代码：

//LRU缓存，以头部节点为最近使用的，尾部节点为最久未使用的

#include <iostream>
#include <unordered_map>
using namespace std;

class DListNode {
public:
	int key, value;
	DListNode* prev;
	DListNode* next;

public:
	DListNode() : key(0), value(0), prev(nullptr), next(nullptr) {};
	DListNode(int _key, int _value) : key(_key), value(_value), prev(nullptr), next(nullptr) {};
};

class LRUcache {
private:
	unordered_map<int, DListNode*> cache;
	DListNode* head;
	DListNode* tail;
	int capacity;
	int size;

public:
	LRUcache(int _capacity) {
		head = new DListNode();
		tail = new DListNode();
		capacity = _capacity;
		size = 0;
		head->next = tail;
		tail->prev = head;
	}

	int get(int key) {
		if (!cache.count(key)) return -1;
		DListNode* node = cache[key];
		refresh(node);
		return node->value;
	}

	void put(int key, int value) {
		if (cache.count(key)) {
			DListNode* node = cache[key];
			node->value = value;
			refresh(node);
		}
		else {
			DListNode* node = new DListNode(key, value);
			cache[key] = node;
			refresh(node);
			size++;
			if (size > capacity) {
				DListNode* removedNode = tail->prev;
				remove(removedNode);
				cache.erase(removedNode->key);
				delete removedNode;
				size--;
			}
		}
	}

	void refresh(DListNode* node) {
		remove(node);
		node->prev = head;
		node->next = head->next;
		head->next->prev = node;
		head->next = node;
	}

	void remove(DListNode* node) {
		if (node->next != nullptr) {
			node->prev->next = node->next;
			node->next->prev = node->prev;
		}
	}
};

void test() {
	LRUcache lru(2);
	lru.put(1, 1);
	lru.put(2, 2);
	cout << lru.get(1) << endl;
	lru.put(3, 3);
	cout << lru.get(2) << endl;
	lru.put(4, 4);
	cout << lru.get(1) << endl;
	cout << lru.get(3) << endl;
	cout << lru.get(4) << endl;
}

int main() {
	
	test();

	system("pause");
	return 0;
}

输入：

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

运行结果：

稍敛风翼
关注
LRU缓存算法c++实现
可乐小浣熊
07-26 1万+
    在如今的项目开发中，缓存是一种必不可少的存储方式，目前在各种后台开发中，比较常见的一种缓存算法就是LRU了，LRU名为最近最少使用算法。它会将最近不常用的缓存数据淘汰掉，是一种Cache替换算法。      本文通过c++简单的实现这种算法，代码不长，但能很好的体现这种思想      思路：  map  存储数据 ，实现查找效率O(1)，双向链表实现算法逻辑      算法逻辑： 1....
LRU算法 C++实现
06-30
操作系统中的一个算法 C++实现的，Lru算法
LRU算法（C++实现）
热门推荐
邹亮的博客
03-29 1万+
一、LRU算法简介 对于web开发而言，缓存必不可少，也是提高性能最常用的方式。无论是浏览器缓存，还是服务端的缓存(通过memcached或者redis等内存数据库)。缓存不仅可以加速用户的访问，同时也可以降低服务器的负载和压力。那么，了解常见的缓存淘汰算法的策略和原理就显得特别重要。 常见的缓存算法 LRU (Least recently used) 最近最少使用，如果数据最近被访问过，那...
深入理解内存管理：LRU、FIFO和CLOCK页面置换算法解析
最新发布
weixin_29069575的博客
09-29 1464
本文还有配套的精品资源，点击获取 简介：在操作系统中，页面置换算法对于高效管理虚拟内存至关重要，它们决定内存中的页面如何被替换以释放空间。本文将详细分析三种关键的页面置换算法：LRU（最近最少使用）、FIFO（先进先出）和CLOCK（时钟算法），探讨它们的工作原理、优势、劣势以及实现开销。通过分析工作负载，我们可以评估这些算法在不同情况下的表现，并为系统设计提供指导。 ...
C++实现LRU算法（LeetCode 146 LRU缓存机制）
暮色年华的博客
11-24 1875
LRU算法： LRU算法（Least Recently Used）是一种缓存淘汰策略，最近使用的数据是有用的， 如果缓存满了，删除最久没用过的数据 LRU算法描述： （1）设置缓存大小 （2）get：在缓存中根据key索引value，如果缓存中没有，返回-1 （3）put：如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。 class LRUCache { public
c++实现LRU算法
SteveForever的博客
05-22 584
c++实现LRU算法 #include <iostream> #include <list> #include <utility> #include <vector> #include <unordered_map> #include <memory> using namespace std; class LRUCache { public: unordered_map<int, list<pair<in
LRU算法实现（C++版本）
11-05
1.资源包含LRU算法整个项目，可直接在vs2019上运行项目，如果版本不对可选择把项目中cpp文件复制到自己的vs中运行 2.LRU 算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。 3.如果积分不够可以私信我私发给你
lrucacheleetcode-LRU_Cache_Algorithm:用C++实现LRU缓存算法
06-29
（LRU缓存算法） C++版本，适用于 ##LRU算法介绍 引自： Discards the least recently used items first. This algorithm requires keeping track of what was used when, which is expensive if one wants to make ...
c++实现的常见缓存算法和LRU
08-31
LRU缓存算法是计算机科学中用于管理有限存储空间的一种策略，尤其在处理高速缓存或内存数据库时非常常见。LRU全称为“Least Recently Used”，即最近最少使用。该算法的基本思想是：如果一个数据最近被访问过，那么...
C++实现的LRU缓存算法（带定期/不定期过期时间）
12-25
本算法为 C++ 实现的 LRU 缓存算法，包含普通 LRU、定时过期的 LRU、不定时过期的LRU，数据结构为双向链表及哈希表结合的方式，实现了 get() 和 put() 两个操作，且所有操作的平均时间复杂度均可以控制在 O(1) 内。
LRU 算法 C++实现
juggte的博客
11-14 3108
实现LRU LRU(Least Recently Used)，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 t，当须淘汰一个页面时，选择现有页面中其 t 值最大的，即最近最少使用的页面予以淘汰,常用于缓存机制。 实现LRU需要一个Map和一个双向链表。 我们规定，head->next 为最久未使用节点，head->prev为最新节点，这样就可以保证其相对次序。 map的value保存链
LRU算法C++实现
Coder567
03-21 515
使用unordered_map 和 双向链表简单实现的LRU算法 #include <iostream> #include <unordered_map> using namespace std; struct CacheNode { int key; int value; CacheNode *pre, *next; CacheNode(int k, int v) : key(k), value(v), pre(nullptr), next(nullptr) {}
Lru算法C++实现
weixin_42210846的博客
05-11 506
#pragma once #include <unordered_map> #include <list> #include <utility> template<typename T = int> class Lru { using value_type = typename std::list<std::pair<int, T>>::iterator; public: void printList(); void inse
C++实现LRU算法
SteveForever的博客
11-14 1651
利用双向链表和哈希表实现LRU算法 双向链表 使用双向链表可以快速删除和添加元素，来移动最近使用的节点，将最近使用的节点保存到双向链表的尾端。快速的put值和value。 哈希表 使用哈希表可以快速的查找节点。快速get关键值为key的value。 LRU算法 实现 LRUCache 类： LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void
lru c++ 实现
wenfh2020的专栏
03-19 715
LRU（Least recently used，最近最少使用），数据插入队列中，经常访问的数据单元靠近列表头部，不经常访问的靠近列表尾部。列表数据就像按照时间排序一样。常用来淘汰一些长时间不使用的数据。 算法流程 lru 算法用一个列表也可以实现。只是列表数据需要更新操作，那得先查找数据，列表的查找时间复杂度是 O(n)O(n)O(n)，这是个低效的操作，所以用时间复杂度为 $ O(1) $ 的...
LRU算法 c++实现
weixin_39052554的博客
08-13 341
LRU全程Least Recently Used，最近最少使用的意思，是一种内存管理方法，该算法最早应用于操作系统。 #include<list> #include<string> #include<unordered_map> using namespace std; template<class KeyType, class ValueType> class LRUCache { public: LRUCache(int capacity) : m
C++ LRU算法
一个大佬的博客
06-13 639
【代码】C++ LRU算法。
C++实现LRU缓存（新手入门详解）
ZY52678的博客
07-18 981
LRU（Least Recently Used，最近最少使用）是一种常用的缓存淘汰策略，主要目的是在缓存空间有限的情况下，优先淘汰那些最长时间没有被访问的数据项。并添加了一些整数元素。然后，我们遍历并打印链表中的元素，删除头部和尾部的元素，并再次打印链表中的元素。方法用于插入或更新缓存中的键值对，如果缓存已满，则淘汰最不常用的键（链表尾部的键）。：随着数据访问模式的变化，LRU策略可以动态调整缓存中的数据项，以适应访问模式的变化。：每次数据项被访问时，都会更新其访问记录，使得最近访问的数据项保留在缓存中。
C++实现LRU
freshman94的博客
04-01 2215
LRU缓存算法也叫LRU页面置换算法，是一种经典常用的页面置换算法 LRU的典型实现是hash map + doubly linked list，双向链表用于存储数据结点，并且它是按照结点最近被使用的时间来存储的。如果一个结点被访问了，我们有理由相信它在接下来的一段时间被访问的概率要大于其它结点。于是，我们把它放到双向链表的头部。当我们往双向链表里插入一个结点，我们也有可能很快就会使用到它，同样把...
深入解析LRU缓存算法原理与实现
资源摘要信息: "LRU算法作为缓存算法中的经典，是...文件名称"LRU.CPP"暗示着该文件包含了使用C++实现LRU算法的源代码。开发者在实现该算法时，需要关注数据结构的选择和高效算法的具体实现，以确保缓存性能达到最优。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值