C++ 一步一步实现LRU

最新推荐文章于 2024-03-09 16:10:44 发布
最新推荐文章于 2024-03-09 16:10:44 发布
阅读量1.4k 收藏 10
点赞数 3
分类专栏： C++ 数据结构 文章标签： c++ 数据结构 算法 lru 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011609555/article/details/107669145
版权

C++ 一步一步写LRU

什么是LRU

LRU(Least recently used)，它其实是一个Queue，当其中某个元素被使用时，就把该元素从从队列中重新拿回到队首，如此进行下去，最不经常被访问的元素，就很容易被剔除队列。以此，LRU中保存的始终都是最常被访问的元素了，淘汰的都是不常访问的元素。
LRU的兄弟还有LFU (Least frequently used)，原理和LRU恰好相反。

什么场景使用LRU

LRU是最常接触的缓存策略，想想操作系统中学习的页面置换算法。LRU就是常用的页面置换算法之一，操作系统的内存就是通过LRU的策略进行页的换出和换入，LRU算法是比较接近理想的一种页面置换算法，这种算法既充分利用了内存中页面调用的历史信息，又正确反映了程序的局部问题。
LRU也同样在工程代码中经常出现，使用的场景也经常为淘汰算法，缓存策略等等。例如Android使用LRU策略进行实现内存缓存，Redis中也有一个近似LRU的算法，感兴趣的小伙伴可以去深挖一下，这里就不多做剖析了。

如何实现一个LRU

1. LRU中保存的元素

template<typename K, typename V>
class Entry final
{
public:
    K key;
    V value;
};

保存的元素最好使用模板，K用来索引元素，V为真正的元素类型

2. LRU中使用链表

template<typename K, typename V>
using Iter = typename std::list<Entry<K, V>>::iterator;

template<typename K, typename V>
class List final
{
public:
    List() : capacity_(0) {}

    ~List()
    {
        lst_.clear();
    }

    uint get_capacity() const
    {
        return capacity_;
    }

    Iter<K, V> push_front(Entry<K, V> &entry)
    {
        ++capacity_;
        return lst_.insert(lst_.begin(), entry);
    }

    Iter<K, V> move_to_front(Iter<K, V> &it)
    {
        auto v = (*it);
        lst_.erase(it);
        return lst_.insert(lst_.begin(), v);
    }

    bool remove(Iter<K, V> &it)
    {
        if (lst_.size() > 0 && capacity_ > 0)
        {
            --capacity_;
            lst_.erase(it);
            return true;
        }

        return false;
    }

    Iter<K, V> back()
    {
        if (lst_.size() > 0 && capacity_ > 0)
            return (--lst_.end());

        return lst_.end();
    }

    bool is_end(Iter<K, V> it) const
    {
        return it != lst_.end();
    }

private:
    uint capacity_;
    list<Entry<K, V>> lst_;
};

在LRU里要使用这个链表的目的是什么呢？答案是保存元素的容器。这个容器的实现有很多种，我看到过很多种不同的容易来管理元素的（vector, unordered_map等），追究其根本，核心功能就是使用这个数据结构进行元素位置的调整。因为当元素被访问时，整个LRU需要将这个元素重新放置在队首。为满足这个需求，大家可以分析一下是不是链表的操作要略强一些，还有没有更优的数据结构在存放（可以牺牲空间）。

3. LRU的实现

template<typename K, typename V>
class LRUQueue final
{
public:
	// 构造函数，默认容量1024
    explicit LRUQueue(uint fixedCapacity = 1024)
            : fixed_capacity_(fixedCapacity)
    {}
	// 默认析够
    ~LRUQueue() = default;

	// 插入元素
    void insert(const K &key, const V &value);

	// 获取元素，并调整元素位置
    V get(const K &key);

	// 从LRU中手动移除
    bool remove(const K &key);

private:
	// 从list和map中移除元素
    inline void delete_(Iter<K, V> &it);

private:
    uint fixed_capacity_;
    std::unordered_map<K, Iter<K, V>> lru_map_;
    List<K, V> lru_list_;
};

简单描述一下实现原理

  • LRUQueue`中成员主要两个
    • List<K, V> lru_list_: LRU中缓存元素的列表
    • std::unordered_map<uint, Iter<K, V>> lru_map_;这个Map保存LRU元素的key和在List中Iterator，方便在List中快速定位和进行操作。
  • 整个LRUQueue类包含如下几个成员方法：
    • void insert(const K &key, const V &value) : 向LRU中插入元素
    • V get(const K &key): 从LRU中获取Key的元素
    • bool remove(const K &key): 从LRU中手动移除元素，返回true表示元素在LRU中并成功移除，否则返回false。这个方法在LRU的实现中可有可无，根据需求自行使用。

LRU优化

上述的LRU结构是否足够优雅，效率是否达到了最佳，我们来一起探讨一下。优化主要方向围绕时间效率展开，针对插入insert和读取get进行讨论：

分析LRUQueue::get()

V LRUQueue::get(const K &key)
{
    auto it = lru_map_.find(key);
    if (it == lru_map_.end())
        return V();

    auto new_it = lru_list_.move_to_front(it->second);
    lru_map_[key] = new_it;

    return new_it->value;
}

Iter<K, V> List::move_to_front(Iter<K, V> &it)
{
    lst_.erase(it);
    return lst_.insert(lst_.begin(), (*it));
}

这个方法中有两个主要的问题：

  1. 返回的类型为模板V，这就要求实际的类具有拷贝构造函数，如果key不在LRU中，返回的V()还要求具备构造函数;
  2. 存储元素的容器list在将元素重新插入到队首时，做了两步操作先erase元素，再将元素insert到队首，有没有简单的方法来进行迁移。

针对这两个问题，分别给出修复的方案：

  1. 针对返回V时要求具备构造和拷贝构造的问题，有两个解决方案，一个是返回List的Interator,另一个是容器中保存std::shared_ptr<V>
  2. 因为list没有方法直接完成将某个元素重新放到队首的方法，只能先erase再insert。并且整个操作的过程还要使用Interator。优化的方法，可以使用Linux底层的数据结构list_head或者自己写一个简单的保存了头指针的双向链表数据结构。

分析LRUQueue::insert()

void insert(const K &key, const V &value)
{
    auto it = lru_map_.find(key);
    if (it != lru_map_.end())
    {
        lru_map_[key] = lru_list_.move_to_front(it->second);
        return;
    }

    auto entry = Entry<K, V>{key, value};
    lru_map_[key] = lru_list_.push_front(entry);
    
    if (lru_list_.get_capacity() > fixed_capacity_)
    {
        auto end = lru_list_.back();
        delete_(end);
    }
}

插入LRU的问题和解决：

  1. 插入的操作需要根据业务需求进行设计。例如，重复插入是否报错，应不应该更新元素;
  2. Map一定要保存List的Interator吗，是否可以保存双向链表的指针本身;
  3. 当超过容量限制时，操作删除还是基于Interator进行，可以优化成指针的直接操作,或者彻底废弃删除接口

其他问题

  1. 整个LRU不是线程安全的，希望线程安全的话，需要LRU中添加锁
  2. Entry数据结构不需要再重复保存key值.

最终实现

#ifndef MYUTILS_LRUQUEUE_H
#define MYUTILS_LRUQUEUE_H

#include <string>
#include <map>
#include <list>
#include <unordered_map>
#include <memory>

#include "DisableCopyAndAssign.h"

using std::list;
using std::string;

template<typename K, typename V>
class Entry
{
public:
    typedef std::shared_ptr<V> ValuePtr;
    explicit Entry(K key, V *ptr) : key(key), value(ptr) {}

    ~Entry()
    {
        next = nullptr;
        pre = nullptr;
    }

    K key;
    ValuePtr value;
    Entry *next = nullptr;
    Entry *pre = nullptr;
};

template<typename K, typename V>
class List final
{
public:
    typedef Entry<K, V> EntryType;

    // 禁用拷贝构造和等号运算符
    DISABLE_COPY_AND_ASSIGN(List);

    List() = default;

    ~List()
    {
        clear();
    }

    void clear()
    {
        EntryType *temp;
        auto ptr = first_->next;
        while (ptr != last_)
        {
            temp = ptr->next;
            first_->next = temp;
            temp->pre = first_;
            delete ptr;
            ptr = temp;
        }

        delete ptr;
        size_ = 0;
        first_ = nullptr;
        last_ = nullptr;
    }

    template <class...Args>
    EntryType *emplace_front(Args&&... args)
    {
        auto entry = new EntryType(std::forward<Args>(args)...);
        return emplace_front(entry);
    }

    EntryType *emplace_front(EntryType *entry)
    {
        if(size_ == 0)
        {
            first_ = entry;
            last_ = entry;
            first_->next = last_;
            last_->pre = first_;
            size_ = 1;
        }
        else
        {
            entry->pre = last_;
            entry->next = first_;
            first_->pre = entry;
            last_->pre = entry;
            first_ = entry;
            ++size_;
        }
        return entry;
    }

    template <class...Args>
    EntryType *emplace_back(Args&&... args)
    {
        auto entry = new EntryType(std::forward<Args>(args)...);
        return emplace_back(entry);
    }

    EntryType *emplace_back(EntryType *entry)
    {
        if(size_ == 0)
        {
            first_ = entry;
            last_ = entry;
            first_->next = last_;
            last_->pre = first_;
            size_ = 1;
        }
        else
        {
            last_->next = entry;
            entry->pre = last_;
            last_ = entry;
            first_->pre = last_;
            size_++;
        }
    }

    K pop_front()
    {
        auto ptr = first_;
        first_ = first_->next;
        auto key = ptr->key;
        delete ptr;
        if(!first_)
            last_ = nullptr;
        --size_;
        return key;
    }

    K pop_back()
    {
        auto ptr = last_;
        last_ = last_->pre;
        auto key = ptr->key;
        delete ptr;
        if(!last_)
            first_ = nullptr;
        --size_;
        return key;
    }


    void move_to_front(EntryType *entry)
    {
        if(!entry || empty() || size_ == 1 || entry == first_)
             return;
        if(entry == last_)
            entry->pre->next = nullptr;
        else
        {
            entry->pre->next = entry->next;
            entry->next->pre = entry->pre;
        }
        // 下面emplace_front会重新将计数+1
        --size_;
        emplace_front(entry);
    }

    EntryType *front() const
    {
        return first_;
    }

    EntryType *back() const
    {
        return last_;
    }

    uint64_t size() const
    {
        return size_;
    }

    bool empty() const
    {
        return size_ == 0;
    }

    template <typename FUNCTION>
    void for_each(FUNCTION &&func)
    {
        auto ptr = first_;
        while (ptr)
        {
            func(ptr->value);
            ptr = ptr->next;
        }
    }

private:
    uint64_t size_ = 0;
    EntryType *first_ = nullptr;
    EntryType *last_ = nullptr;
};

template<typename K, typename V>
class LRUQueue final
{
public:
    typedef std::shared_ptr<V> ValuePtr;

    // 禁用拷贝构造和等号运算符
    DISABLE_COPY_AND_ASSIGN(LRUQueue);

    explicit LRUQueue(uint fixedCapacity = 1024) : fixed_capacity_(fixedCapacity) {}

    ~LRUQueue() = default;

    template <class...Args>
    void insert(const K &key, Args&&... args)
    {
        auto it = lru_map_.find(key);
        if (it != lru_map_.end())
        {
            // 插入重复元素，只更新位置
            lru_list_.move_to_front(it->second);
            return;
        }

        auto entry = new Entry<K, V>(key, new V(std::forward<Args>(args)...));
        lru_map_[key] = lru_list_.emplace_front(entry);

        if (lru_list_.size() > fixed_capacity_)
            lru_map_.erase(lru_list_.pop_back());
    }

    ValuePtr get(const K &key)
    {
        auto it = lru_map_.find(key);
        if (it == lru_map_.end())
            return nullptr;

        lru_list_.move_to_front(it->second);
        return it->second->value;
    }

private:
    uint fixed_capacity_;
    std::unordered_map<K, Entry<K, V> *> lru_map_;
    List<K, V> lru_list_;
};

#endif

链接：github仓库地址，欢迎点星

小眼睛的程序员
关注
专栏目录
【C/C++ 性能优化】提高C++程序的缓存命中率以优化性能
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
02-13 2444
在探讨计算机性能优化的旅程中，我们常常被引导去关注算法的复杂度、代码的优化，或是更高效的数据结构。然而，有一个经常被忽视的角色在幕后默默地影响着程序的运行效率——那就是缓存（Cache）。正如哲学家亨利·戴维·梭罗在《瓦尔登湖》中所说：“细节是造成美丽的源泉”，在软件开发的世界里，对缓存的理解和优化，就是那些决定程序性能优雅与否的细节。
LRU算法 C++实现
06-30
操作系统中的一个算法 C++实现的，Lru算法
LRU 算法 C++实现
juggte的博客
11-14 3102
实现LRU LRU(Least Recently Used)，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 t，当须淘汰一个页面时，选择现有页面中其 t 值最大的，即最近最少使用的页面予以淘汰,常用于缓存机制。 实现LRU需要一个Map和一个双向链表。 我们规定，head->next 为最久未使用节点，head->prev为最新节点，这样就可以保证其相对次序。 map的value保存链
LRU算法（C++实现）
热门推荐
邹亮的博客
03-29 1万+
一、LRU算法简介 对于web开发而言，缓存必不可少，也是提高性能最常用的方式。无论是浏览器缓存，还是服务端的缓存(通过memcached或者redis等内存数据库)。缓存不仅可以加速用户的访问，同时也可以降低服务器的负载和压力。那么，了解常见的缓存淘汰算法的策略和原理就显得特别重要。 常见的缓存算法 LRU (Least recently used) 最近最少使用，如果数据最近被访问过，那...
lru c++ 实现
wenfh2020的专栏
03-19 713
LRU（Least recently used，最近最少使用），数据插入队列中，经常访问的数据单元靠近列表头部，不经常访问的靠近列表尾部。列表数据就像按照时间排序一样。常用来淘汰一些长时间不使用的数据。 算法流程 lru 算法用一个列表也可以实现。只是列表数据需要更新操作，那得先查找数据，列表的查找时间复杂度是 O(n)O(n)O(n)，这是个低效的操作，所以用时间复杂度为 $ O(1) $ 的...
LRU 算法实现 （C++实现）
Appleeatingboy的博客
08-02 2012
LeetCode 146题： 运用你所掌握的数据结构，设计和实现一个LRU (最近最少使用) 缓存机制 。 实现 LRUCache 类： LRUCache(int capacity) 以正整数作为容量capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达...
页面置换算法——LRU的简易实现(C++)
szy0321的博客
05-18 1707
LRU 最近最久未使⽤的置换算法（LRU）：最近最久未使用（LRU）的置换算法的基本思路是，发生缺页时，选择最长时间没有被访问的页面进行置换，也就是说，该算法假设已经很久没有使用的页面很有可能在未来较长的⼀段时间内仍然不会被使用。 图解： 最后一步因为1号页面是「过去时间段里最久没有被访问的」， 所以把1号页面换出到磁盘，然后把3号页面换入到内存。 代码简易实现 #include<iostream> #include<list> #include<map> using
yemianzhihuansuanfa.rar_FIFO LRU OPT_LRU_MFC置换页面_mfc fifo_opt fi
09-21
这个项目可能包含了一个模拟器，可以运行FIFO、LRU和OPT算法，并通过图形化的方式显示每一步操作，以便用户观察不同算法在相同输入下的行为差异。 为了深入理解这些算法，你可以通过阅读和分析代码来查看它们如何在...
用C++实现双向链表
06-28
在编程领域，链表是一种非常基础且重要的数据结构...这个数据结构在许多算法和数据结构问题中都有应用，如实现LRU缓存、解决链表问题等。理解和掌握如何用C++实现双向链表对于提升编程技能和深入理解数据结构至关重要。
最近最久未使用LRU置换算法模拟·
05-21
MFC（Microsoft Foundation Classes）是微软提供的一套C++库，用于构建Windows应用程序。它为开发者提供了丰富的类和函数，简化了Windows API的使用，使得开发具有图形用户界面（GUI）的应用程序变得更加便捷。 在...
LRU算法实现（C++版本）
11-05
1.资源包含LRU算法整个项目，可直接在vs2019上运行项目，如果版本不对可选择把项目中cpp文件复制到自己的vs中运行 2.LRU 算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。 3.如果积分不够可以私信我私发给你
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算法（LeetCode 146 LRU缓存机制）
暮色年华的博客
11-24 1874
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
C++实现LRU
freshman94的博客
04-01 2215
LRU缓存算法也叫LRU页面置换算法，是一种经典常用的页面置换算法 LRU的典型实现是hash map + doubly linked list，双向链表用于存储数据结点，并且它是按照结点最近被使用的时间来存储的。如果一个结点被访问了，我们有理由相信它在接下来的一段时间被访问的概率要大于其它结点。于是，我们把它放到双向链表的头部。当我们往双向链表里插入一个结点，我们也有可能很快就会使用到它，同样把...
【算法】LRU缓存算法的C++实现
最新发布
Conner7的博客
03-09 6149
LRU缓存算法是一种淘汰算法，也是一道经典的面试题，本文对LRU缓存算法的C++实现做了讲解。
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) {}
C++实现LRU算法
ChaseHeart的博客
08-26 790
1、LRU概念： least recently used，最近最少使用是一种存页面置换算法； 缺页异常（缺页中断）：当 CPU 访问的页面不在物理内存时，便会产生⼀个缺页中断，请求操作系统将所缺页调入到物理内存。 在第4步找空闲页，找不到空闲页的话，就说明此时内存已满了，这时候，就需要页面置换算法选择⼀个物理页。 LRU 是通过历史的使用情况来推测要淘汰的页面。额外开销较大：需要寄存器和栈的硬件支持。 完全实现 LRU，需要在内存中维护⼀个所有页面的链表，最近最多使用的页面在表头，最近最少使用的页面在表尾
C++实现LRU页面置换算法详解
"本文将介绍如何使用C++实现LRU（Least Recently Used）页面置换算法。LRU算法是一种常见的缓存淘汰策略，它基于‘最近最少使用’的原则，即如果一个数据最近被访问过，那么它在未来被访问的可能性较高。在内存资源...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值