学习笔记1：c++实现LRU算法

最新推荐文章于 2024-07-18 14:40:29 发布
最新推荐文章于 2024-07-18 14:40:29 发布
阅读量2.2k 收藏
点赞数
分类专栏： 我的私房菜 文章标签： 双向队列 循环队列 hash LRU
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/starcuan/article/details/18182353
版权

LeetCode OJ上有一道题目，要编程实现cache的LRU算法，刚看到这道题的时候，我想到了用队列来做，但是若用单链表来做，必须要保存尾节点的上一个节点指针，才能实现快速增加一条数据，编程起来很不方便，所以我采用了双端队列实现，为了处理方便，保存两个带节点指针，一个节点的next指向头结点，另一个节点next指向尾节点。

LRU算法中还要求将已存在的节点放入队尾或者插入节点时要判断此节点是不是存在，所以我使用hash表来快速的定位到此节点，所以就有节点定义

struct node{
	int key;
	int val;
	node *pre;
	node *next;
	node(int k,int v):key(k),val(v),pre(NULL),next(NULL){}
};

hash定义：

#define MAX 10000//hash表最大长度
#define MOD 9991//大质数

node *Hash[MAX][20];
int len[MAX];//对应每个键值的长度

hash函数为： 

int _hash(int key){
	return key%MOD;
}

双端队列（DQueue）要提供插入一个节点(insert)、删除头结点(delHead)、获取队列大小(size)、根据key值获取节点的value值功能(find)；

其中插入节点时需要判断该节点是不是存在，若存在，需要将其放到队尾，并给其赋新值；根据key值获取节点value值时也要判断节点是否存在，若存在也需将其放入队尾，并返回该节点value值。所以我增加了一个search函数，

函数声明为：

node * search(int key);

该函数功能为，在hash表中查找键值为key的节点，若找不到返回NULL，找到时将该节点拿出来插入到队尾，并返回该节点，具体实现为：

node * search(int key){
	int pos=_hash(key);//找到hash表位置
	for(int i=0;i<len[pos];i++){
		if(key==Hash[pos][i]->key){
			node *t=Hash[pos][i];
			if(t->pre==NULL&&t->next==NULL)return t;//如果该队列中只有一个元素时返回该节点
			if(t->pre==NULL){//若为头结点，还需要对head指针进行操作
				head->next=t->next;
				t->next->pre=NULL;
				t->pre=tail->next;
				tail->next->next=t;
				tail->next=t;
				return t;
			}
			if(t->next==NULL){//若为尾节点
				return t;
			}
			t->pre->next=t->next;//既不是头结点也不是尾节点，只需要对tail指针进行操作
			t->next->pre=t->pre;
			t->pre=tail->next;
			tail->next->next=t;
			t->next=NULL;
			tail->next=t;
			return t;
		}
	}
	return NULL;
}
所以整个DQueue双端队列类实现如下： 

class DQueue{
	node *head;
	node *tail;
	int Size;
	node *Hash[MAX][20];
	int len[MAX];
	int _hash(int key){
		return key%MOD;
	}
	node * search(int key){
		int pos=_hash(key);
		for(int i=0;i<len[pos];i++){
			if(key==Hash[pos][i]->key){
				node *t=Hash[pos][i];
				if(t->pre==NULL&&t->next==NULL)return t;
				if(t->pre==NULL){
					head->next=t->next;
					t->next->pre=NULL;
					t->pre=tail->next;
					tail->next->next=t;
					tail->next=t;
					return t;
				}
				if(t->next==NULL){
					return t;
				}
				t->pre->next=t->next;
				t->next->pre=t->pre;

				t->pre=tail->next;
				tail->next->next=t;
				t->next=NULL;
				tail->next=t;
				return t;
			}
		}
		return NULL;
	}
public:
	DQueue(){
		head=new node(0,0);
		tail=new node(0,0);
		memset(len,0,sizeof(len));
		Size=0;
	}
	int insert(int key,int val){
		
		node *i=search(key);
		if(i!=NULL){
			i->val=val;
			return 1;
		}
		
		node *t=new node(key,val);
		if(!Size){
			head->next=t;
		}
		t->pre=tail->next;
		if(tail->next!=NULL)tail->next->next=t;
		int pos=_hash(t->key);
		Hash[pos][len[pos]++]=t;
		tail->next=t;
		Size++;
		return 1;
	}
	int delHead(){
		node *p=head->next;
		if(p!=NULL){
			head->next=p->next;
			if(p->next!=NULL)p->next->pre=NULL;
			delete[] p;
			Size--;
			return 1;
		}
		return 0;
	}
	int find(int key){
		node *f=search(key);
		if(f!=NULL)return f->val;
		return -1;
	}
	int size(){
		return Size;
	}
};
LRU类实现就比较简单了： 

class LRUCache{
	DQueue *dq;
	int capa;
public:
	LRUCache(int capacity){
		capa=capacity;
		dq=new DQueue();
	}
	int get(int key){
		return dq->find(key);
	}
	void set(int key,int value){
		dq->insert(key,value);//先插入一个节点
		if(dq->size()>capa){//若队列满则删掉头结点
			dq->delHead();
		}
	}
};

整个代码实现加测试程序如下： 

#include <iostream>
#include <windows.h>
#include <random>
#include <stdlib.h>
#include <time.h>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <cmath>
using namespace std;

#define MAX 10000
#define MOD 9991
struct node{
	int key;
	int val;
	node *pre;
	node *next;
	node(int k,int v):key(k),val(v),pre(NULL),next(NULL){}
};


class DQueue{
	node *head;
	node *tail;
	int Size;
	node *Hash[MAX][20];
	int len[MAX];
	int _hash(int key){
		return key%MOD;
	}
	node * search(int key){
		int pos=_hash(key);
		for(int i=0;i<len[pos];i++){
			if(key==Hash[pos][i]->key){
				node *t=Hash[pos][i];
				if(t->pre==NULL&&t->next==NULL)return t;
				if(t->pre==NULL){
					head->next=t->next;
					t->next->pre=NULL;
					t->pre=tail->next;
					tail->next->next=t;
					tail->next=t;
					return t;
				}
				if(t->next==NULL){
					return t;
				}
				t->pre->next=t->next;
				t->next->pre=t->pre;

				t->pre=tail->next;
				tail->next->next=t;
				t->next=NULL;
				tail->next=t;
				return t;
			}
		}
		return NULL;
	}
public:
	DQueue(){
		head=new node(0,0);
		tail=new node(0,0);
		memset(len,0,sizeof(len));
		Size=0;
	}
	int insert(int key,int val){
		
		node *i=search(key);
		if(i!=NULL){
			i->val=val;
			return 1;
		}
		
		node *t=new node(key,val);
		if(!Size){
			head->next=t;
		}
		t->pre=tail->next;
		if(tail->next!=NULL)tail->next->next=t;
		int pos=_hash(t->key);
		Hash[pos][len[pos]++]=t;
		tail->next=t;
		Size++;
		return 1;
	}
	int delHead(){
		node *p=head->next;
		if(p!=NULL){
			head->next=p->next;
			if(p->next!=NULL)p->next->pre=NULL;
			delete[] p;
			Size--;
			return 1;
		}
		return 0;
	}
	int find(int key){
		node *f=search(key);
		if(f!=NULL)return f->val;
		return -1;
	}
	int size(){
		return Size;
	}
};

class LRUCache{
	DQueue *dq;
	int capa;
public:
	LRUCache(int capacity){
		capa=capacity;
		dq=new DQueue();
	}
	int get(int key){
		return dq->find(key);
	}
	void set(int key,int value){
		dq->insert(key,value);
		if(dq->size()>capa){
			dq->delHead();
		}
	}
};
void Test()//测试程序
{
	//freopen("C:\\in.txt","r",stdin);
	LRUCache p(10);
	p.set(10,13),p.set(3,17),p.set(6,11),p.set(10,5),p.set(9,10);
	cout<<p.get(13);
	p.set(2,19);
	cout<<p.get(2);
	cout<<p.get(3);
	p.set(5,25);
	cout<<p.get(8);
	p.set(9,22),p.set(5,5),p.set(1,30);
	cout<<p.get(11);
	p.set(9,12);
	cout<<p.get(7);
	cout<<p.get(5);
	cout<<p.get(8);
	cout<<p.get(9);
	p.set(4,30),p.set(9,3);
	cout<<p.get(9);
	cout<<p.get(10);
	cout<<p.get(10);
	p.set(6,14);p.set(3,1);
	cout<<p.get(3);
	p.set(10,11);
	cout<<p.get(8);
	p.set(2,14);
	cout<<p.get(1);
	cout<<p.get(5);
	cout<<p.get(4);
	p.set(11,4),p.set(12,24),p.set(5,18);
	cout<<p.get(13);
	p.set(7,23);
	cout<<p.get(8);
	cout<<p.get(12);
	p.set(3,27),p.set(2,12);
	cout<<p.get(5);
	p.set(2,9),p.set(13,4);p.set(8,18),p.set(1,7);
	cout<<p.get(6);
	p.set(9,29),p.set(8,21);
	cout<<p.get(5);
	p.set(6,30),p.set(1,12);
	cout<<p.get(10);
	p.set(4,15),p.set(7,22),p.set(11,26),p.set(8,17),p.set(9,29);
	cout<<p.get(5);
	p.set(3,4),p.set(11,30);
	cout<<p.get(12);
	p.set(4,29);
	cout<<p.get(3);
	cout<<p.get(9);
	cout<<p.get(6);
	p.set(3,4);
	cout<<p.get(1);
	cout<<p.get(10);
	p.set(3,29),p.set(10,28),p.set(1,20),p.set(11,13);
	cout<<p.get(3);
	p.set(3,12),p.set(3,8),p.set(10,9),p.set(3,26);
	cout<<p.get(8);
	cout<<p.get(7);
	cout<<p.get(5);
	p.set(13,17),p.set(2,27),p.set(11,15);
	cout<<p.get(12);
	p.set(9,19),p.set(2,15),p.set(3,16);
	cout<<p.get(1);
	p.set(12,17),p.set(9,1),p.set(6,19);
	cout<<p.get(4);
	cout<<p.get(5);
	cout<<p.get(5);
	p.set(8,1),p.set(11,7),p.set(5,2),p.set(9,28);
	cout<<p.get(1);
	p.set(2,2),p.set(7,4),p.set(4,22),p.set(7,24),p.set(9,26),p.set(13,28),p.set(11,26);
	
	printf("\n");
}
     
int main(void)    
{    
    LARGE_INTEGER BegainTime ;    
    LARGE_INTEGER EndTime ;    
    LARGE_INTEGER Frequency ;    
    QueryPerformanceFrequency(&Frequency);    
    QueryPerformanceCounter(&BegainTime) ;    
    
    //要测试的代码放在这里   
    Test();   
     
    QueryPerformanceCounter(&EndTime);   
    
    //输出运行时间（单位：s）   
    cout << "运行时间（单位：s）：" <<(double)( EndTime.QuadPart - BegainTime.QuadPart )/ Frequency.QuadPart <<endl;    
    
    //system("pause") ;    
    return 0 ;    
}

然后我发现，如果用双向循环队列来实现，就不需要对head和tail指针进行维护了，head的pre指针指向队尾，也就是最新添加的元素，head的next指针指向头结点，也就是最早添加的元素，因为使用循环链表，我也不用在队空的时候对head指针进行单独讨论了，因为head的前一个结点和后一个结点都是head本身，所以结点定义稍微修改下，有： 

struct node{
	int key;
	int val;
	node *pre;
	node *next;
	node(int k,int v):key(k),val(v),pre(this),next(this){}
};

整个实现起来就轻松了许多，略作修改后的全部代码贴上： 

#include <iostream>
#include <windows.h>
#include <random>
#include <stdlib.h>
#include <time.h>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <cmath>
using namespace std;

#define MAX 10000
#define MOD 9991
struct node{
	int key;
	int val;
	node *pre;
	node *next;
	node(int k,int v):key(k),val(v),pre(this),next(this){}
};


class DQueue{
	node *head;
	int Size;
	node *Hash[MAX][20];
	int len[MAX];
	int _hash(int key){
		return key%MOD;
	}
	node * search(int key){
		int pos=_hash(key);
		for(int i=0;i<len[pos];i++){
			if(key==Hash[pos][i]->key){
				node *t=Hash[pos][i];
				t->pre->next=t->next;
				t->next->pre=t->pre;
				
				t->pre=head->pre;
				head->pre->next=t;

				t->next=head;
				head->pre=t;
				return t;
			}
		}
		return NULL;
	}
public:
	DQueue(){
		head=new node(0,0);
		memset(len,0,sizeof(len));
		Size=0;
	}
	int insert(int key,int val){
		
		node *i=search(key);
		if(i!=NULL){
			i->val=val;
			return 1;
		}
		
		node *t=new node(key,val);
		
		t->next=head;
		t->pre=head->pre;
		head->pre->next=t;
		head->pre=t;

		int pos=_hash(key);
		Hash[pos][len[pos]++]=t;
		Size++;
		return 1;
	}
	int delHead(){
		node *p=head->next;
		head->next=p->next;
		p->next->pre=head;
		delete[] p;
		Size--;
		return 1;
	}
	int find(int key){
		node *f=search(key);
		if(f!=NULL)return f->val;
		return -1;
	}
	int size(){
		return Size;
	}
};

class LRUCache{
	DQueue *dq;
	int capa;
public:
	LRUCache(int capacity){
		capa=capacity;
		dq=new DQueue();
	}
	int get(int key){
		return dq->find(key);
	}
	void set(int key,int value){
		dq->insert(key,value);
		if(dq->size()>capa){
			dq->delHead();
		}
	}
};
void Test()//测试程序
{
	//freopen("C:\\in.txt","r",stdin);
	LRUCache p(10);
	p.set(10,13),p.set(3,17),p.set(6,11),p.set(10,5),p.set(9,10);
	cout<<p.get(13);
	p.set(2,19);
	cout<<p.get(2);
	cout<<p.get(3);
	p.set(5,25);
	cout<<p.get(8);
	p.set(9,22),p.set(5,5),p.set(1,30);
	cout<<p.get(11);
	p.set(9,12);
	cout<<p.get(7);
	cout<<p.get(5);
	cout<<p.get(8);
	cout<<p.get(9);
	p.set(4,30),p.set(9,3);
	cout<<p.get(9);
	cout<<p.get(10);
	cout<<p.get(10);
	p.set(6,14);p.set(3,1);
	cout<<p.get(3);
	p.set(10,11);
	cout<<p.get(8);
	p.set(2,14);
	cout<<p.get(1);
	cout<<p.get(5);
	cout<<p.get(4);
	p.set(11,4),p.set(12,24),p.set(5,18);
	cout<<p.get(13);
	p.set(7,23);
	cout<<p.get(8);
	cout<<p.get(12);
	p.set(3,27),p.set(2,12);
	cout<<p.get(5);
	p.set(2,9),p.set(13,4);p.set(8,18),p.set(1,7);
	cout<<p.get(6);
	p.set(9,29),p.set(8,21);
	cout<<p.get(5);
	p.set(6,30),p.set(1,12);
	cout<<p.get(10);
	p.set(4,15),p.set(7,22),p.set(11,26),p.set(8,17),p.set(9,29);
	cout<<p.get(5);
	p.set(3,4),p.set(11,30);
	cout<<p.get(12);
	p.set(4,29);
	cout<<p.get(3);
	cout<<p.get(9);
	cout<<p.get(6);
	p.set(3,4);
	cout<<p.get(1);
	cout<<p.get(10);
	p.set(3,29),p.set(10,28),p.set(1,20),p.set(11,13);
	cout<<p.get(3);
	p.set(3,12),p.set(3,8),p.set(10,9),p.set(3,26);
	cout<<p.get(8);
	cout<<p.get(7);
	cout<<p.get(5);
	p.set(13,17),p.set(2,27),p.set(11,15);
	cout<<p.get(12);
	p.set(9,19),p.set(2,15),p.set(3,16);
	cout<<p.get(1);
	p.set(12,17),p.set(9,1),p.set(6,19);
	cout<<p.get(4);
	cout<<p.get(5);
	cout<<p.get(5);
	p.set(8,1),p.set(11,7),p.set(5,2),p.set(9,28);
	cout<<p.get(1);
	p.set(2,2),p.set(7,4),p.set(4,22),p.set(7,24),p.set(9,26),p.set(13,28),p.set(11,26);
	
	printf("\n");
}
     
int main(void)    
{    
    LARGE_INTEGER BegainTime ;    
    LARGE_INTEGER EndTime ;    
    LARGE_INTEGER Frequency ;    
    QueryPerformanceFrequency(&Frequency);    
    QueryPerformanceCounter(&BegainTime) ;    
    
    //要测试的代码放在这里   
    Test();   
     
    QueryPerformanceCounter(&EndTime);   
    
    //输出运行时间（单位：s）   
    cout << "运行时间（单位：s）：" <<(double)( EndTime.QuadPart - BegainTime.QuadPart )/ Frequency.QuadPart <<endl;    
    
    //system("pause") ;    
    return 0 ;    
}

第一篇博客就这么写完了，写的不好还请见谅

_王川
关注
专栏目录
心跳服务的宕机判断：手撕LRU算法
2401_83329402的博客
04-21 816
如果有新的心跳包，则将其插入到双向链表的尾部，那么最老的心跳包就是在双向链表的头部，这样在寻找宕机的主机时，只要看双向链表头部最老的心跳包，距现在是否超过 5 秒，如果超过 5秒 则认为该主机宕机，然后将其从双向链表中删除。这样，在发现双向链表中头部的节点超时了，由于节点的内容是键值对，于是就能快速地从该节点获取主机的 IP ，知道了主机的 IP 信息，就能把哈希表中该主机信息删除。为了维持队列里的心跳包是主机最新上报的，所以要先找到该主机旧的心跳包，然后将其删除，再把新的心跳包插入到双向链表的队尾。
学习总结：C++中STL的数据结构
一只程序小洋的博客
08-16 3312
1.STL介绍 STL（Standard Template Library），即标准模板库，是一个具有工业强度的，高效的C++程序库。它被容纳于C++标准程序库（C++ Standard Library）中，是ANSI/ISO C++标准中最新的也是极具革命性的一部分。该库包含了诸多在计算机科学领域里所常用的基本数据结构和基本算法。为广大C++程序员们提供了一个可扩展的应用框架，高度体现了软件的可复用性。 2.C++STL提供的数据结构 1. Sequence Containers：维持顺序的容器。
LRU算法 C++实现
06-30
操作系统中的一个算法 C++实现的，Lru算法
LRU 算法 C++实现
juggte的博客
11-14 3083
实现LRU LRU(Least Recently Used)，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 t，当须淘汰一个页面时，选择现有页面中其 t 值最大的，即最近最少使用的页面予以淘汰,常用于缓存机制。 实现LRU需要一个Map和一个双向链表。 我们规定，head->next 为最久未使用节点，head->prev为最新节点，这样就可以保证其相对次序。 map的value保存链
C++实现LRU缓存（新手入门详解）
最新发布
ZY52678的博客
07-18 891
LRU（Least Recently Used，最近最少使用）是一种常用的缓存淘汰策略，主要目的是在缓存空间有限的情况下，优先淘汰那些最长时间没有被访问的数据项。并添加了一些整数元素。然后，我们遍历并打印链表中的元素，删除头部和尾部的元素，并再次打印链表中的元素。方法用于插入或更新缓存中的键值对，如果缓存已满，则淘汰最不常用的键（链表尾部的键）。：随着数据访问模式的变化，LRU策略可以动态调整缓存中的数据项，以适应访问模式的变化。：每次数据项被访问时，都会更新其访问记录，使得最近访问的数据项保留在缓存中。
C++实现LRU算法
weixin_39318565的博客
06-28 535
LRU 算法的基本思想是，当缓存空间已满时，将最久未被访问的数据项淘汰出去，为新的数据项让出空间。如果数据项存在于缓存中，更新该数据项的值，并将其移动到链表头部，表示它是最近被访问的数据项。LRU 算法通过维护数据项的访问顺序，将最近访问的数据项放在链表的前面，保证了频繁访问的数据项能够快速被命中，提高缓存的命中率。通常选择双向链表，其中链表头部表示最近访问的数据项，链表尾部表示最久未被访问的数据项。如果数据项存在于缓存中，将该数据项从当前位置移动到链表头部，表示它是最近被访问的数据项。
LRU算法（C++实现）
邹亮的博客
03-29 1万+
一、LRU算法简介 对于web开发而言，缓存必不可少，也是提高性能最常用的方式。无论是浏览器缓存，还是服务端的缓存(通过memcached或者redis等内存数据库)。缓存不仅可以加速用户的访问，同时也可以降低服务器的负载和压力。那么，了解常见的缓存淘汰算法的策略和原理就显得特别重要。 常见的缓存算法 LRU (Least recently used) 最近最少使用，如果数据最近被访问过，那...
LRU算法c++实现
John_ToStr的博客
11-11 1097
//LRU的实现 LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰 // 利用双向链表实现 // 双向链表有一个特点就是它的链表是双路的，我们定义好头节点和尾节点，然后利用先进先出（FIFO），最近被放入的数据会最早被获取。 // 其中主要涉及到添加、访问、修改、删除操作。首先是添加，如果是新元素，直接放在链表头上面，其他的元素顺序往下移动；访问的话， // 在头节点的可以不用管，如果是在中间位置或者尾巴，就要将数据移动到头
C++学习笔记和实践项目，实践项目包括Json工具类、设计模式的C++实现、消息队列、智能指针，linux下的并发控制工具等
03-08
C++学习笔记和实践项目，实践项目包括Json工具类、设计模式的C++实现、消息队列、智能指针，linux下的并发控制工具、线程池，epoll管理器和Mysql连接池、STL容器的快捷输出工具和页面置换算法（FIFO, LRU, LFU）的...
网易校园招聘历年经典面试题汇总：C++研发岗，java面试题怎么刷
2401_84433658的博客
04-20 436
现在其实从大厂招聘需求可见，在招聘要求上有高并发经验优先，包括很多朋友之前都是做传统行业或者外包项目，一直在小公司，技术搞的比较简单，没有怎么搞过分布式系统，但是现在互联网公司一般都是做分布式系统。所以说，如果你想进大厂，想脱离传统行业，这些技术知识都是你必备的，下面自己手打了一份Java并发体系思维导图，希望对你有所帮助。网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
Android学习笔记：Android基础知识点（不断更新中）
热门推荐
浩比的专栏
10-28 2万+
1、Android系统的四大组件分别是：活动（Activity）、服务（Service）、广播接收器（Broadcast Receiver）、内容提供器（Content Provider）。 2、定义一个应用程序名的字符串，有以下两种方式来引用它：
LRU算法实现（C++版本）
11-05
1.资源包含LRU算法整个项目，可直接在vs2019上运行项目，如果版本不对可选择把项目中cpp文件复制到自己的vs中运行 2.LRU 算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。 3.如果积分不够可以私信我私发给你
c++模拟操作系统LRU算法
10-21
文档内部为实验报告（包含全部代码及演示图）。操作系统的lru页面置换
lru c++ 实现
wenfh2020的专栏
03-19 703
LRU（Least recently used，最近最少使用），数据插入队列中，经常访问的数据单元靠近列表头部，不经常访问的靠近列表尾部。列表数据就像按照时间排序一样。常用来淘汰一些长时间不使用的数据。 算法流程 lru 算法用一个列表也可以实现。只是列表数据需要更新操作，那得先查找数据，列表的查找时间复杂度是 O(n)O(n)O(n)，这是个低效的操作，所以用时间复杂度为 $ O(1) $ 的...
LRU算法C++实现
Coder567
03-21 506
使用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) {}
C++实现LRU算法（LeetCode 146 LRU缓存机制）
暮色年华的博客
11-24 1861
LRU算法： LRU算法（Least Recently Used）是一种缓存淘汰策略，最近使用的数据是有用的， 如果缓存满了，删除最久没用过的数据 LRU算法描述： （1）设置缓存大小 （2）get：在缓存中根据key索引value，如果缓存中没有，返回-1 （3）put：如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。 class LRUCache { public
c++实现LRU算法
SteveForever的博客
05-22 574
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
C++【LRU】
芊樱烛渊的博客
12-23 896
因为我们的磁盘->内存->高速缓存->cpu之间的速度不同，所以我们设置了缓存缓存空间满了之后，更新数据，我要进入，谁出去呢？LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。，将最近最少被使用的算法替换出去。（包括读和写）
模拟分页：FIFO与LRU算法实现与比较
LRU算法的实现通常需要额外的数据结构，如链表，来记录页面的访问历史，以便快速找到最久未使用的页面。 - 实验中，用户同样输入页面访问序列，程序通过查找页表确定缺页情况，并在内存满时按LRU原则淘汰最不常用的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值