【算法】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....
C++实现的LRU缓存算法（带定期/不定期过期时间）
12-25
本算法为 C++ 实现的 LRU 缓存算法，包含普通 LRU、定时过期的 LRU、不定时过期的LRU，数据结构为双向链表及哈希表结合的方式，实现了 get() 和 put() 两个操作，且所有操作的平均时间复杂度均可以控制在 O(1) 内。
c++实现的常见缓存算法和LRU
08-31
LRU缓存算法也叫LRU页面置换算法，是一种经典常用的页面置换算法，下面这篇文章主要介绍了c++实现的常见缓存算法和LRU,需要的朋友可以参考借鉴，下面来一起看看吧。
【常见缓存算法原理及其C++实现】LRU篇（包含过期时间详解）
saxon_li的博客
04-05 9285
一、缓存算法简介 （一）缓存算法应用背景 缓存的应用场景和范围十分广泛，下面给出其十分常见的两种应用背景： 首先，在操作系统内部，由于内存资源十分有限，而每个进程又都希望独享一块很大的内存空间。所以诞生了一种“虚拟内存”机制，它将进程的一部分内容暂留在磁盘中，在需要时再进行数据交换将其放入内存，这个过程就需要用到缓存算法机制进行置换。 其次，对于各类应用项目开发而言，在巨大的数据量面前，Catch 是不可或缺的。因为无论是针对本地端的浏览器缓存，还...
数据结构-LRU缓存（C语言实现）
最新发布
pyc68的博客
10-01 1042
本篇文章主要是为了记录实现LRU缓存的方法和思考的过程。
LRU算法 C++实现
06-30
操作系统中的一个算法 C++实现的，Lru算法
LRU算法（C++实现）
热门推荐
邹亮的博客
03-29 1万+
一、LRU算法简介 对于web开发而言，缓存必不可少，也是提高性能最常用的方式。无论是浏览器缓存，还是服务端的缓存(通过memcached或者redis等内存数据库)。缓存不仅可以加速用户的访问，同时也可以降低服务器的负载和压力。那么，了解常见的缓存淘汰算法的策略和原理就显得特别重要。 常见的缓存算法 LRU (Least recently used) 最近最少使用，如果数据最近被访问过，那...
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 581
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 ...
LRU 算法 C++实现
juggte的博客
11-14 3104
实现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 505
#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 713
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 633
【代码】C++ LRU算法。
C++实现LRU缓存（新手入门详解）
ZY52678的博客
07-18 967
LRU（Least Recently Used，最近最少使用）是一种常用的缓存淘汰策略，主要目的是在缓存空间有限的情况下，优先淘汰那些最长时间没有被访问的数据项。并添加了一些整数元素。然后，我们遍历并打印链表中的元素，删除头部和尾部的元素，并再次打印链表中的元素。方法用于插入或更新缓存中的键值对，如果缓存已满，则淘汰最不常用的键（链表尾部的键）。：随着数据访问模式的变化，LRU策略可以动态调整缓存中的数据项，以适应访问模式的变化。：每次数据项被访问时，都会更新其访问记录，使得最近访问的数据项保留在缓存中。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值