LRU缓存设计

最新推荐文章于 2024-08-16 15:19:46 发布
最新推荐文章于 2024-08-16 15:19:46 发布
阅读量1.3w 收藏 21
点赞数 1
分类专栏： C++ 算法 文章标签： iterator class insert null 数据结构 table
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ryfdizuo/article/details/7916996
版权
C++ 同时被 2 个专栏收录
153 篇文章 1 订阅
订阅专栏
算法
62 篇文章 0 订阅
订阅专栏

缓存的数据结构采用哈希表，key到value的映射。

网上有些资料采用记录数据的使用时刻 实现LRU策略，此处采用双向链表 实现LRU策略。LRU Least Recently Used，MRU Most Recently Used

双向链表，lruPtr头指向最近最少使用的元素，mruPtr头指向最近最多使用的元素。

LRUCache<int, int> tc(3);  //最大三个元素
tc.insert(1, 101);
tc.insert(2, 102);
tc.insert(3, 103);

最终存储结构如下图：

哈希表中的元素：

  • 黄色是 key域，哈希的键
  • 蓝色是value域，存储的数据值
  • 红色是newerPtr 域，指向下一个更新的 哈希项
  • 绿色是oldPtr域，指向前一个更旧的 哈希项
LRUCache缓存中 保存mruPtr和lruPtr，缓存的查找、更新元素 首先从hash_table中发起，然后同步更新到双向链表中。

lru.hpp

/*
* Implementation of an LRU cache with a maximum size.
*
* See http://code.google.com/p/lru-cache-cpp/ for usage and limitations.
*
* Licensed under the GNU LGPL: http://www.gnu.org/copyleft/lesser.html
*
* Pierre-Luc Brunelle, 2011
* pierre-luc.brunelle@polytml.ca
*
* 使用stl中的map替换hash_table
* Peteryfren China, 2012
*/

#include <map>
#include <sstream>
#include <cassert>

namespace lru{

	//-------------------------------------------------------------
	// Bucket
	//-------------------------------------------------------------

	template<class K, class V>
	struct LRUCacheH4Value
	{
		typedef std::pair<const K, LRUCacheH4Value<K, V> > Val;

		LRUCacheH4Value()
			: _v(), _older(NULL), _newer(NULL) { }

		LRUCacheH4Value(const V & v, Val * older, Val * newer)
			: _v(v), _older(older), _newer(newer) { } 

		V _v;
		Val * _older;
		Val * _newer;
	};


	//-------------------------------------------------------------
	// Const Iterator
	//-------------------------------------------------------------

	template<class K, class V>
	class LRUCacheH4ConstIterator
	{
	public:
		typedef std::pair<const K, LRUCacheH4Value<K, V> > Val;
		typedef LRUCacheH4ConstIterator<K, V> const_iterator;
		typedef Val & reference;
		typedef Val * pointer;

		enum DIRECTION {
			MRU_TO_LRU = 0,
			LRU_TO_MRU
		};

		LRUCacheH4ConstIterator(const Val * ptr = NULL, DIRECTION dir = MRU_TO_LRU);

		const_iterator & operator++();
		const_iterator operator++(int);

		bool operator==(const const_iterator & other);
		bool operator!=(const const_iterator & other);

		const K & key() const;
		const V & value() const;

	private:
		const Val * _ptr;
		DIRECTION _dir;
	};


	template<class K, class V>
	LRUCacheH4ConstIterator<K, V>::LRUCacheH4ConstIterator(
		const typename LRUCacheH4ConstIterator<K, V>::Val * ptr,
		typename LRUCacheH4ConstIterator<K, V>::DIRECTION dir)
		: _ptr(ptr), _dir(dir)
	{
	}


	template<class K, class V>
	LRUCacheH4ConstIterator<K, V> & LRUCacheH4ConstIterator<K, V>::operator++()
	{
		assert(_ptr);
		_ptr = (_dir == LRUCacheH4ConstIterator<K, V>::MRU_TO_LRU ? _ptr->second._older : _ptr->second._newer);
		return *this;
	}


	template<class K, class V>
	LRUCacheH4ConstIterator<K, V> LRUCacheH4ConstIterator<K, V>::operator++(int)
	{
		const_iterator ret = *this;
		++*this;
		return ret;
	}


	template<class K, class V>
	bool LRUCacheH4ConstIterator<K, V>::operator==(const const_iterator & other)
	{
		return _ptr == other._ptr;
	}


	template<class K, class V>
	bool LRUCacheH4ConstIterator<K, V>::operator!=(const const_iterator & other)
	{
		return _ptr != other._ptr;
	}


	template<class K, class V>
	const K & LRUCacheH4ConstIterator<K, V>::key() const
	{
		assert(_ptr);
		return _ptr->first;
	}


	template<class K, class V>
	const V & LRUCacheH4ConstIterator<K, V>::value() const
	{
		assert(_ptr); 
		return _ptr->second._v;
	}


} // file scope


namespace lru {

	//-------------------------------------------------------------
	// LRU Cache
	//-------------------------------------------------------------

	template<class K, class V>
	class LRUCacheH4
	{
	public:
		typedef LRUCacheH4ConstIterator<K, V> const_iterator;

	public:
		LRUCacheH4(int maxsize);                    // Pre-condition: maxsize >= 1
		LRUCacheH4(const LRUCacheH4 & other);
		~LRUCacheH4() { _map.clear(); }

		V & operator[](const K & key);
		void insert(const K & key, const V & value);

		int size() const;
		int maxsize() const;
		bool empty() const;

		const_iterator find(const K & key);         // updates the MRU
		const_iterator find(const K & key) const;   // does not update the MRU
		const_iterator mru_begin() const;           // from MRU to LRU
		const_iterator lru_begin() const;           // from LRU to MRU
		const_iterator end() const;

		void dump_mru_to_lru(std::ostream & os) const;

	private:
		typedef std::pair<const K, LRUCacheH4Value<K, V> > Val;

		typedef std::map<K, LRUCacheH4Value<K,V> > MAP_TYPE;

	private:
		Val * _update_or_insert(const K & key);
		Val * _update(typename MAP_TYPE::iterator it);
		Val * _insert(const K & key);

	private:
		MAP_TYPE _map;
		Val * _mru;
		Val * _lru;
		int _maxsize;
	};


	// Reserve enough space to avoid resizing later on and thus invalidate iterators
	template<class K, class V>
	LRUCacheH4<K, V>::LRUCacheH4(int maxsize)
		: _mru(NULL),
		_lru(NULL),
		_maxsize(maxsize)
	{
		if (_maxsize <= 0)
			throw "LRUCacheH4: expecting cache size >= 1";
	}


	template<class K, class V>
	LRUCacheH4<K, V>::LRUCacheH4(const LRUCacheH4<K, V> & other)
		: _maxsize(other._maxsize),
		_mru(NULL),
		_lru(NULL)
	{
		for (const_iterator it = other.lru_begin();  it != other.end();  ++it)
			this->insert(it.key(), it.value());
	}


	template<class K, class V>
	V & LRUCacheH4<K, V>::operator[](const K & key)
	{
		return _update_or_insert(key)->second._v;
	}


	template<class K, class V>
	void LRUCacheH4<K, V>::insert(const K & key, const V & value)
	{
		_update_or_insert(key)->second._v = value;
	}


	template<class K, class V>
	int LRUCacheH4<K, V>::size() const
	{
		return _map.size();
	}


	template<class K, class V>
	int LRUCacheH4<K, V>::maxsize() const 
	{
		return _maxsize;
	}


	template<class K, class V>
	bool LRUCacheH4<K, V>::empty() const
	{
		return size() > 0;
	}


	// updates MRU
	template<class K, class V>
	typename LRUCacheH4<K, V>::const_iterator LRUCacheH4<K, V>::find(const K & key)
	{
		typename MAP_TYPE::iterator it = _map.find(key);

		if (it != _map.end())
			return const_iterator(_update(it), const_iterator::MRU_TO_LRU);
		else
			return end();
	}


	// does not update MRU
	template<class K, class V>
	typename LRUCacheH4<K, V>::const_iterator LRUCacheH4<K, V>::find(const K & key) const
	{
		typename MAP_TYPE::iterator it = _map.find(key);

		if (it != _map.end())
			return const_iterator(&*it, const_iterator::MRU_TO_LRU);
		else
			return end();
	}


	template<class K, class V>
	void LRUCacheH4<K, V>::dump_mru_to_lru(std::ostream & os) const
	{
		os << "LRUCacheH4(" << size() << "/" << maxsize() << "): MRU --> LRU: " << std::endl;
		for (const_iterator it = mru_begin();  it != end();  ++it)
			os << it.key() << ": " << it.value() << std::endl;
	}


	template<class K, class V>
	typename LRUCacheH4<K, V>::const_iterator LRUCacheH4<K, V>::mru_begin() const
	{
		return const_iterator(_mru, const_iterator::MRU_TO_LRU);
	}


	template<class K, class V>
	typename LRUCacheH4<K, V>::const_iterator LRUCacheH4<K, V>::lru_begin() const
	{
		return const_iterator(_lru, const_iterator::LRU_TO_MRU);
	}


	template<class K, class V>
	typename LRUCacheH4<K, V>::const_iterator LRUCacheH4<K, V>::end() const
	{
		return const_iterator();
	}


	template<class K, class V>
	typename LRUCacheH4<K, V>::Val * LRUCacheH4<K, V>::_update_or_insert(const K & key)
	{
		typename MAP_TYPE::iterator it = _map.find(key);
		if (it != _map.end())
			return _update(it);
		else
			return _insert(key);
	}


	template<class K, class V>
	typename LRUCacheH4<K, V>::Val * LRUCacheH4<K, V>::_update(typename MAP_TYPE::iterator it)
	{
		LRUCacheH4Value<K, V> & v = it->second;
		Val * older = v._older;
		Val * newer = v._newer;
		Val * moved = &*it;

		// possibly update the LRU
		if (moved == _lru && _lru->second._newer)
			_lru = _lru->second._newer;

		if (moved != _mru) {
			// "remove" key from current position
			if (older)
				older->second._newer = newer;
			if (newer)
				newer->second._older = older;

			// "insert" key to MRU position
			v._older = _mru;
			v._newer = NULL;
			_mru->second._newer = moved;
			_mru = moved;
		}

		return moved;
	}


	template<class K, class V>
	typename LRUCacheH4<K, V>::Val * LRUCacheH4<K, V>::_insert(const K & key)
	{
		// if we have grown too large, remove LRU
		if (_map.size() >= _maxsize) {
			Val * old_lru = _lru;
			if (_lru->second._newer) {
				_lru = _lru->second._newer;
				_lru->second._older = NULL;
			}
			_map.erase(old_lru->first);
		}

		// insert key to MRU position
 		std::pair<typename MAP_TYPE::iterator, bool> ret
 			= _map.insert( Val(key, LRUCacheH4Value<K, V>(V(), _mru, NULL)) );

		Val * inserted = &*ret.first;
		if (_mru)
			_mru->second._newer = inserted;
		_mru = inserted;

		// possibly update the LRU
		if (!_lru)
			_lru = _mru;
		else if (!_lru->second._newer)
			_lru->second._newer = _mru;

		return inserted;
	}


}  // namespace lru

测试代码： 

#include <iostream>

#include "lru.hpp"

using namespace lru;
using namespace std;

int main()
{
	typedef LRUCacheH4<int, int> CacheType;

	CacheType tc(3);

	tc.insert(1, 101);
	tc.insert(2, 102);
	tc.insert(3, 103);
	
	tc.insert(2, 1002);

	cout << tc[1] << endl;

	cout << "================" << endl;

	for (CacheType::const_iterator it = tc.mru_begin();  it != tc.end();  ++it)
		cout << it.key() << " " << it.value() << endl;

	cout << "================" << endl;

	for (CacheType::const_iterator it = tc.lru_begin();  it != tc.end();  ++it)
		cout << it.key() << " " << it.value() << endl;

	system("PAUSE");
	return 0;
}
参考：

1. High-Throughput, Thread-Safe, LRU Caching
http://www.ebaytechblog.com/2011/08/30/high-throughput-thread-safe-lru-caching/



ryfdizuo
关注
专栏目录
如何设计一个LRU Cache？
07-24 2万+
如何设计一个LRU Cache？Google和百度的面试题都出现了设计一个Cache的题目，什么是Cache，如何设计简单的Cache，通过搜集资料，本文给出个总结。 通常的问题描述可以是这样：Question：[1] Design a layer in front of a s
LRU缓存设计O(1)复杂度
Gee_Zer的博客
09-22 367
题目描述 设计LRU缓存结构，该结构在构造时确定大小，假设大小为K，并有如下两个功能 set(key, value)：将记录(key, value)插入该结构 get(key)：返回key对应的value值 [要求] set和get方法的时间复杂度为O(1) 某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。 当缓存的大小超过K时，移除最不经常使用的记录，即set或get最久远的。 若opt=1，接下来两个整数x, y，表示set(x, y) 若opt=2，接下来一个整数x，表示g
设计LRU缓存结构算法
m0_49961610的博客
11-29 515
LRU缓存结构
算法：LRU（Least Recently Used）
最新发布
AWSDN的博客
08-16 565
本文主要介绍LRU的知识
LRU缓存的设计
rekingman的博客
01-10 2036
LRU缓存设计 文章目录LRU缓存设计什么是LRULRU缓存设计设计步骤代码实现 什么是LRU 概念 LRU的初始设计与应用是在操作系统中的虚拟存储模块上，它作为操作系统的虚拟页面置换的算法，得到了广泛的应用。 特点与应用 由于操作系统的页表大小有限，页面项的数量也有限，当我们访问某个物理块的时候，可能产生缺页中断，这个时候操作系统就会触发调页请求，从外存置换对应的物理页进入内存，提供访...
设计LRU缓存结构
SevenLee的个人博客
02-17 123
/** * lru design * @param operators int整型二维数组 the ops * @param k int整型 the k * @return int整型一维数组 */ function LRU( operators , k ) { // write code here let cache = new Map() let result = [] for(let i = 0; i < operators.length; i++).
详解Java实现LRU缓存
08-18
Java 中实现 LRU 缓存有多种方法，包括使用 LinkedHashMap 和自己设计数据结构。使用 LinkedHashMap 实现 LRU 缓存是最简单的方法，因为 LinkedHashMap 自身已经实现了顺序存储，默认情况下是按照元素的添加顺序存储...
面试题：如何实现一个简单的LRU缓存设计 Java解法
NinoSun的博客
03-16 246
LRU缓存设计题（即Java中LinkHashMap实现原理） 题表 设计LRU缓存结构，该结构在构造时确定大小，假设大小为K，并有如下两个功能 set(key, value)：将记录(key, value)插入该结构 get(key)：返回key对应的value值 [要求] set和get方法的时间复杂度为O(1) 某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。 当缓存的大小超过K时，移除最不经常使用的记录，即set或get最久远的。 若opt=1，接下来两个整数x,
java实现LRU缓存
路漫
08-10 432
1.自定义双向链表的形式 原理就是通过维护一个双向链表，每次操作的时候都把操作的节点放到头部（get / set）。 不说废话直接上代码 public static class Node { public Node(String key, String value){ this.value = value; this.key = key; } Node pre; Node next;
设计LRU缓存结构Python实现
02-12
设计LRU(最近最少使用)缓存结构，该结构在构造时确定大小，假设大小为 capacity ，操作次数是 n ，并有如下功能: 1. Solution(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存 2. get(key)：如果关键字 ...
Lru缓存算法的简易设计及实现
weixin_72125569的博客
09-08 1110
Lru缓存算法设计及使用
[Leetcode] 设计LRU缓存机制
chinanfsk的博客
08-20 648
设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。 写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留...
LRU缓存算法设计
legend_go的博客
04-04 401
LRU(Least Recently Used)：最近最少使用，其核心思想是一个数据在一段时间内没有被访问到，那么在将来一段时间内被访问到的概率也不大，因此在存储空间满后，应当将那些最近最少使用的数据进行删除，为最新添加的数据腾出空间。和LRU相似的算法还有FIFO(First In FIrst Out)算法，即先进先出算法，很明显完美符合了队列的特点，因此可以利用队列进行实现。以上介绍的算法经常被用于操作系统的内存页置换，当然也可以用作缓存的设计。
39、设计LRU缓存结构
sunnnnh的博客
05-09 137
一、题目 设计LRU缓存结构，该结构在构造时确定大小，假设大小为K，并有如下两个功能 set(key, value)：将记录(key, value)插入该结构 get(key)：返回key对应的value值 [要求] set和get方法的时间复杂度为O(1) 某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。 当缓存的大小超过K时，移除最不经常使用的记录，即set或get最久远的。 若opt=1，接下来两个整数x, y，表示set(x, y) 若opt=2，接下来一个整
LRU缓存机制设计与实现
偶然i的博客
08-11 427
什么是LRU Cache LRU是Least Recently Used的缩写，意思是最近最久使用，它是一种Cache替换算法。 什么是Cache？ 狭义 的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较 快速的SRAM技术。 广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。除了CPU与主存之间有Cache， 内存与硬盘之间也有Cache，乃至在硬盘与网络之间也有某种意义上的Ca...
2021-10-24设计LRU缓存
qq_36647920的博客
10-24 101
注意：需要用到unordered_map和list两个数据结构，其中需要用到的方法有list.remove(int val),可以直接移除list中值为val的所有元素。而list.erase(iterator)是迭代器的精准删除。 描述 设计LRU(最近最少使用)缓存结构，该结构在构造时确定大小，假设大小为 k ，并有如下两个功能 set(key, value)：将记录(key, value)插入该结构 get(key)：返回key对应的value值 提示: 1.某个key的set或get操作一旦发生
LRU缓存算法缓存设计和实现
csdn_kou的博客
09-30 1039
什么是缓存？ 举个例子，去图书馆查资料，一般情况下我们会集中把我们有可能查阅的几本书从书架取下来，放在我们的桌面上，以便交叉查阅，从而避免频繁的从座位上跑到书架旁去取书。在这个例子里，书桌所扮演的就是缓存的角色。 缓存有两个特点： 能在某种程度上降低访问数据的成本； 其容量远小于外部存储的容量，如本例子中，书桌上能容纳的书本数就远小于书架的。 什么是 LRU 缓存? LRU 缓存是一种以 LR...
牛客网：设计LRU缓存结构 设计LFU缓存结构
weixin_46266058的博客
06-26 835
链表 数据结构 牛客网 C++
LeetCode LRU缓存设计与实现：高效查找与内存管理
书中提到的"时间内查找节点"这一概念主要应用于数据结构和算法设计中的缓存（LRU Cache）策略，用于提高查找效率。 LRU（Least Recently Used，最近最少使用）缓存是一种常用的数据结构，它维护一个固定大小的缓存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值