LRU与LFU缓存实现（c++）

已于 2023-03-12 21:11:05 修改
阅读量289 收藏
点赞数 1
文章标签： 缓存 c++ 数据结构
于 2023-03-12 21:08:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wkelas/article/details/129469301
版权

背景

进程通过malloc函数申请内存时，分配到的内存是虚拟内存，并不是实际的物理内存，且此时内存管理单元没有完成虚拟内存到物理内存的映射。当程序需要访问虚拟内存时，发现该内存并没有映射到物理内存上，会产生缺页中断。进入缺页中断后判断是否有可分配的物理内存，如果有，这时才会分配物理页并通过MMU的页表来建立虚拟内存到物理内存的映射。

如果没有可分配的物理内存，则会按顺序进行后台内存回收、直接内存回收，如果进行内存回收后仍无法满足需求，则会出发OOM机制，杀死占用内存较大的进程。

若缺页中断后发现物理内存中没有可分配的空闲页，则需要使用页面置换算法选择物理页（脏页）置环到磁盘，本文主要介绍其中LRU、LFU。

LRU算法选择最长时间没被访问的内存页进行置环，一般通过维护链表来实现，链表头部区域是经常访问的内存，尾部区域是不常访问的内存，也就是优先回收链表尾部的内存。LFU算法选择访问次数最少的页面进行置换，若访问次数相同，则对相同次数的页面使用LRU算法来进一步判断置换掉哪一页。

LRU

题目

在这里插入图片描述

数据结构

LRU算法保证在每次访问元素时，需将该元素插入到链表头部，若当前容量大于维护的容量时，需要从尾部删除元素，链表的插入删除很方便，时间复杂度满足要求；但是查找元素时需要遍历，这时可考虑用哈希表映射，实现查询也满足O(1)的时间复杂度。
如下图所示：哈希表里存放key–>node的映射关系，双向链表里也含有key的原因是因为后续删除链表时，需要同时删除哈希表里的对应元素。
在这里插入图片描述

具体实现

双向链表结点的定义

四个元素：key、value以及前驱节点与后继结点

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

LRUCache类

初始化

定义初始化的成员变量：头尾结点、哈希表、容量、当前大小

class LRUCache {
public:
    LRUCache(int capacity) : capacity_(capacity), size_(0){				//数据结构初始化
        head = new DoubleList();
        tail = new DoubleList();
        head->next = tail;
        tail->prev = head;
        //*******************
        //
        //*******************
    }
private:
    DoubleList *head;
    DoubleList *tail;
    unordered_map<int, DoubleList *> map;
    int size_;
    int capacity_;  
};
主要接口实现

put()
若没有该元素，则new出该元素结点，将其加入链表头部，在哈希表里也加入映射关系，因为新加入元素，需要判断大小是否超出LRUCache的容量，若超出，删除尾结点以及对应的哈希表映射。若有，则更新value，并加入链表头部。

void put(int key, int value) {
    if (map.find(key) == map.end()) {
        DoubleList *node = new DoubleList(key, value);
        //map[key] = node;
        map.insert(pair<int, DoubleList*>(key, node));
        addHead(node);
        size_++;
        if (size_ > capacity_) {
            DoubleList *tmp = tail->prev;
            removeNode(tmp);
            map.erase(tmp->key); //需要删除哈希表，所以node里也有key
            delete(tmp);
            size_--;
        }
    }
    else {
        DoubleList *node = map[key];
        node->value = value;
        moveToHead(node);
    }
}

get()
若元素存在，则返回该值，并将元素放入链表头节点

 int get(int key) {
     if (map.find(key) == map.end()) {
         return -1;
     }
     else {
         DoubleList *node = map[key];
         moveToHead(node);
         return node->value;
     }
 }

addHead()，removeNode()，moveToHead()等与双链表相关的操作就不赘述了…
这里与操作链表相关的函数写在了LRUCache类中，其实应该定义一个结点类和一个双向链表的类，将链表相关操作封装在链表类里。后面LFU会写规范一点。

LFU

题目

在这里插入图片描述

数据结构

特点：

  • FreqDoubleList链表存放的是按访问次数从小到大排序的结点
  • DoubleList里的是真正的存放数据的结点
  • FreqDoubleList中的每一个freqNode结点下面都有自己的DoubleList
  • freq_map存放访问的key与存储访问该key的次数的结点freqNode的映射；
  • lru_map与前述LRU算法中的map一样，不同的是这里可以映射到多个链表的结点。每个freqNode下面都有一个LRU双链表，因为访问次数相同的话，要根据LRU算法再进一步决策。

在这里插入图片描述

具体实现

结点类与链表类的定义

  • LRUDoubleList链表与其Node 的定义：

在链表类中实现插入删除结点的接口，与前面类似。不同之处在于isempty()，该函数表示判断此LRUDoubleList是否没存数据，因为该链表是属于freqNode的，若进行操作后没有访问次数等于freqNode->fre_的数据，则ferqNode要删除，所以要判断该链表是否为空，进而对没用的freqNode结点删除。

class Node {
public:
    int key_;
    int value_;
    Node *prev;
    Node *next;
    Node():key_(0), value_(0), prev(nullptr), next(nullptr){}
    Node(int key, int value):key_(key), value_(value), prev(nullptr), next(nullptr){}
};

class LRUDoubleList {
public:
    Node *head;
    Node *tail;
    LRUDoubleList():head(new Node()), tail(new Node()) {
        head->next = tail;
        tail->prev = head;
    }

    void addHead(Node *node) {
        node->next = head->next;
        node->prev = head;
        head->next->prev = node;
        head->next = node;
    }

    Node* delNode(Node *node){
        node->next->prev = node->prev;
        node->prev->next = node->next;        
        return node;
    }

    Node* delLast() {
        return delNode(tail->prev);
    } 

    bool isempty() {
        return head->next == tail;
    }

};
  • FreDoubleList链表与其freqNode 的定义：

比较重要的地方在FreDoubleList头尾节点赋值与addCurFreq()函数

class FreqNode {
public:
  int freq_;
  FreqNode *prev;
  FreqNode *next;
  //*****************一个freqNode结点对应一个LRU链表*****************
  LRUDoubleList *dl; 
  
  //explicit防止隐式转换，其实就是想稍微规范一点所以写成这样
  explicit FreqNode(int freq):freq_(freq), prev(nullptr), next(nullptr), dl(new LRUDoubleList()){}
  
};

class FreDoubleList {
public:
  FreqNode *head;
  FreqNode *tail;
  
  // 初始化freqDoubleList时头尾节点可设置为 0 与 INT_MAX
  FreDoubleList():head(new FreqNode(0)), tail(new FreqNode(INT_MAX)) {
      head->next = tail;
      tail->prev = head;
  }

  //当前频率次数加一
  void addCurFreq(FreqNode *cur) {
      //if not exist, create new freq;
      if (cur->freq_ + 1 != cur->next->freq_) {
          FreqNode *newFreqNode = new FreqNode(cur->freq_ + 1);

          newFreqNode->next = cur->next;
          newFreqNode->prev = cur;
          cur->next->prev = newFreqNode;
          cur->next = newFreqNode;
      }
  }

  void delFreqNode(FreqNode *node) {
      node->next->prev = node->prev;
      node->prev->next = node->next;
  }
};

LFUCache类

成员变量定义

前文所述需要的两个散列表；表示访问次数的链表，还有其下的LRU链表（创建freqNode时创建）；存放数据的容量

private:
    //int size_;
    int capacity_;
    unordered_map<int, FreqNode*> fre_map;
    unordered_map<int, Node*> lru_map;
    FreDoubleList *fl;
接口实现

get()
没找到直接返回-1；
若找到，先删除原有的结点，然后更新数据结构

int get(int key) {
	//没找到该数据，直接返回-1
    if (lru_map.find(key) == lru_map.end()) {
        return -1;
    }
 	//数据存在，进行两个步骤：1。删除原有的；2.更新数据结构
    //1 、delete old
    //访问次数+1，故先增加对应的freqNode结点
    FreqNode *before = fre_map[key];
    fl->addCurFreq(before);
    
    //访问了，所以fre + 1,即before->next就是刚增加的ferqNode结点
    FreqNode* after = before->next;     
    Node *targetNode = lru_map[key];
    //删除原先的freqNode下的LRU链表中的结点
    before->dl->delNode(targetNode);
    //判断该LRU链表还是否有元素，没有则阐述freqNode结点
    if (before->dl->isempty()) {
        fl->delFreqNode(before);
    }
    //2、update to the next freq node
    after->dl->addHead(targetNode);  //更新frqNode下的LRU链表里的结点
    fre_map[key] = after;           //访问次数改变了，需要更新映射
    return targetNode->value_;
   
}

put()

void put(int key, int value) {
    if (capacity_ == 0) return;
    if (lru_map.find(key) != lru_map.end()) {
        lru_map[key]->value_ = value;
        get(key);
    } 
    else {			//若没有元素，则需要添加
        if(lru_map.size() == capacity_) {
            //if will out of size, shoule delete node(Last LruNode in first LRUDoubledList)
            FreqNode *node = fl->head->next;
            Node *nodeToDel = node->dl->delLast();
            //delete map
            lru_map.erase(nodeToDel->key_);
            fre_map.erase(nodeToDel->key_); 
            //最少频率列没有元素了，删除  ....
            if (node->dl->isempty()) {
                fl->delFreqNode(node);
            }
        }
    
        //add node must update fl->head
        fl->addCurFreq(f1->head);
        Node *newNode = new Node(key, value);
        fre_map[key] = fl->head->next;
        lru_map[key] = newNode;
        //************注意这里的结构嵌套****************
        fl->head->next->dl->addHead(newNode);
    }
}

小结

LFU的编写更加规范，将链表与其结点分别定义，结构较清晰。今天的一天都在写LRU与LFU。。。溜了写基金去了

亦久亦旧a
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
设计LRU/LFU缓存结构
weixin_47651920的博客
08-19 562
模拟LRU和LFU
FIFO算法，LRU算法，LFU算法的C++实现
IMUDGES_XXX的博客
12-11 742
参考：https://www.cnblogs.com/qq136155330/p/10817299.html #include <iostream> #include <cstdio> #include <fstream> #include <algorithm> #include <cmath> #include <...
LFUCache
AndrewYZWang的博客
03-13 842
LFUCache LFU是Least Frequently Used的缩写，即最不经常最少使用算法，也是一种常用的页面置换算法，选择访问计数器最小的页面，并予以淘汰。 根据LFU的策略，我们每次访问对象都需要更新访问计数器，当插入B的时候，发现缓存中有B，所以增加访问计数器，兵把B移动到访问计数器从大到小排序的地方。当插入一个元素时，先更新访问计数器，在移动到它排序以后的位置，如果页面中已经满了，就将末尾的元素进行剔除 当插入一个数据时，尾部有多个数据计数器值相同，这个时候插入是从相同计数器顶端开始插入
lfu算法实现c语言_缓存算法（页面置换算法）-FIFO、LFU、LRU
weixin_42361834的博客
02-26 829
1. FIFO -- 先进先出如果一个数据最先进入缓存中，则应该最早淘汰掉。也就是说，当缓存满的时候，应当把最先进入缓存的数据给淘汰掉。实现：利用一个双向链表保存数据，当来了新的数据之后便添加到链表末尾，如果Cache存满数据，则把链表头部数据删除，然后把新的数据添加到链表末尾。在访问数据的时候，如果在Cache中存在该数据的话，则返回对应的value值；否则返回-1。如果想提高访问效率，可以利用...
LFU的实现
最新发布
solego’s blog
09-12 243
LFU的实现
【常见缓存算法原理及其C++实现】LRU篇（包含过期时间详解）
saxon_li的博客
04-05 6807
一、缓存算法简介 （一）缓存算法应用背景 缓存的应用场景和范围十分广泛，下面给出其十分常见的两种应用背景： 首先，在操作系统内部，由于内存资源十分有限，而每个进程又都希望独享一块很大的内存空间。所以诞生了一种“虚拟内存”机制，它将进程的一部分内容暂留在磁盘中，在需要时再进行数据交换将其放入内存，这个过程就需要用到缓存算法机制进行置换。 其次，对于各类应用项目开发而言，在巨大的数据量面前，Catch 是不可或缺的。因为无论是针对本地端的浏览器缓存，还...
python进阶（数据分析numpy库 二）
鲨鱼儿的博客
11-20 487
2、ndarray数组的切片： （1）数组切片的基本知识 各个维度上单独切片，用 “，” 隔开，用 “：”表示该维度切片（切片不需要加[ ] --- 例： arr1[np.ix_([1,3],1:4)]，零碎的行需要加[ ] ------- 例：arr1[[1,3,4]]）。 数组切片获得的 新...
【常见缓存算法原理及其C++实现】LFU篇
saxon_li的博客
04-06 3822
一、缓存算法简介 （一）缓存算法应用背景 缓存的应用场景和范围十分广泛，下面给出其十分常见的两种应用背景： 首先，在操作系统内部，由于内存资源十分有限，而每个进程又都希望独享一块很大的内存空间。所以诞生了一种“虚拟内存”机制，它将进程的一部分内容暂留在磁盘中，在需要时再进行数据交换将其放入内存，这个过程就需要用到缓存算法机制进行置换。 其次，对于各类应用项目开发而言，在巨大的数据量面前，Cache是不可或缺的。因为无论是针对本地端的浏览器缓存，还是针...
LFU Cache
leetcode 解题思路
01-03 440
LFU (Least Frequently Used) is a famous cache eviction algorithm. For a cache with capacityk, if the cache is full and need to evict a key in it, the key with the lease frequently used will be kicke...
一文详解 利用LinkedHashMap实现Lru机制
bjxiaxueliang的CODING技术小馆
05-22 2077
Android中的LRU采用什么机制实现的？ 通过这篇文章我们一起进行分析。
缓存：LRU，LFU，FIFO缓存C ++实现
01-30
缓存：LRU，LFU，FIFO缓存C ++实现
javalruleetcode-JavaCache:具有可配置驱逐策略（LRU或LFU）的缓存实现
06-29
java lru leetcode 缓存 具有可配置驱逐策略（LRU 或 LFU）的缓存实现 LRU 策略的灵感来自 SO 的这个解决方案： LFU 策略是使用这种方法实现的，时间复杂度为 O(1)：
LRU算法实现（C++版本）
11-05
1.资源包含LRU算法整个项目，可直接在vs2019上运行项目，如果版本不对可选择把项目中cpp文件复制到自己的vs中运行 2.LRU 算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也...
dw-cache:双窗口缓存使用两个滑动窗口自适应地协调LRU与LFU的比率
03-07
双窗口缓存 双窗口缓存使用两个滑动窗口自适应地协调LRU与LFU的比率。性能比较命中率 （％） LRU的x0.9-2.8命中率更高。 'LRU hit rate even 100', 10.0505'DWC hit rate even 100', 10.113'LFU ratio even 100', 43...
FIFO，LRU，LFU 的三种页面置换算法的C++实现
04-09
OS操作系统上机题 FIFO，LRU，LFU 的三种页面置换算法的C++实现 {3,2,1,3,2,5,2,3,6,2,1,4,2} 为本实验例子的页面走向 copy直接可运行 提供简单可视化菜单 三种页面置换算法可供选择 注释详细，初学者亦可看懂
lfu算法c语言,LeetCode算法系列 460. LFU 缓存机制
weixin_42306503的博客
05-24 320
力扣原题460. LFU 缓存机制请你为 最不经常使用(LFU)缓存算法设计并实现数据结构。实现 LFUCache 类：LFUCache(int capacity) - 用数据结构的容量capacity 初始化对象int get(int key)- 如果键存在于缓存中，则获取键的值，否则返回 -1。void put(int key, int value)- 如果键已存在，则变更其值；如果键不...
java 最少使用(lru)置换算法_缓存淘汰算法LRU和LFU
weixin_39721924的博客
11-23 287
前言LRU算法和LFU算法是属于页面置换的一种算法，或者更通俗的说，就是缓存如何淘汰的一种策略。我们通常在设计一个系统的时候，由于数据库的读取速度远小于内存的读取速度，所以为了加快读取速度，会将一部分数据放到内存中，称为缓存。但是内存容量是有限的，当你要缓存的数据超出容量，就得有部分数据删除，这时候哪些数据删除，哪些数据保留，就是LRU算法和LFU算法要干的事。什么是LRU算法LRU算法，全称Le...
最最最简单的C++缓存实现
qq_21431111的专栏
12-03 1万+
最最最简单的C++缓存实现 在平常的后台开发中，通常中会用到缓存，一般会使用redis等内存数据库来实现，但是在很简单的程序中，其实没必要包含一些额外的依赖，通过C++的map即可实现。
C++笔试题之LRU Cache原理和实现
热门推荐
草上爬的博客
12-12 2万+
C++笔试题之LRU Cache原理和实现 LeetCode上有着样一道题目： Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set. get(key) - Get the value (will always be pos
lru lfu c++
09-02
LRU (Least Recently Used) 和 LFU (Least Frequently Used) 都是常用的缓存淘汰算法。它们都用于在缓存空间不足时决定哪些数据应该被淘汰，以便为新的数据腾出空间。 LRU 算法根据数据的访问时间来进行淘汰，即最近最少使用的数据被淘汰。当一个数据被访问时，它会被移动到缓存的顶部，而最久未访问的数据则会被淘汰。 LFU 算法根据数据的访问频率来进行淘汰，即使用次数最少的数据被淘汰。当一个数据被访问时，其访问频率会被增加。当缓存空间不足时，LFU 算法会淘汰访问频率最低的数据。 以上是关于 LRU 和 LFU 缓存淘汰算法的简要介绍。若有进一步的问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值