C++基础:实现LRU 缓存

一、设计

设计 LRUCache 类:

  • LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存。
  • int get(int key) 如果关键字 key 存在于缓存中,则返回关键字的值,否则返回 -1 。
  • void put(int key, int value) 如果关键字已经存在,则变更其数据值;如果关键字不存在,则插入该组「关键字-值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。

二、实现

使用c++ stl中的双向链表list和map结合,list连接各个节点并通过key将节点的迭代器存放在map中。

  • map:这里主要起到随机访问的作用
  • list:这里起到连接节点之间的关系的作用,主要是更具get和put来改变节点的位置。
  • 关键:
    关键是结构的定义,这里list必须关联key用于删除要淘汰的节点对应的map元素。需要使用pair构建数据对**(key,value)**。
    list<pair<int,int>> m_list;
    map<int,list<pair<int,int>>::iterator> m_cacheMap;
class LRUCache {
public:
    LRUCache(int capacity):
    m_capacity(capacity)
    {

    }
    
    int get(int key) {
        auto iterMap = m_cacheMap.find(key);
        int ret = -1;
        //查表没有直接返回-1
        if(iterMap == m_cacheMap.end()){
            return ret;
        }
        ret = iterMap->second->second;
        m_list.erase(iterMap->second);
        m_list.push_front(make_pair(key, ret));
        m_cacheMap[key] = m_list.begin();
        return ret;
    }
    
    void put(int key, int value) {
        auto iterMap = m_cacheMap.find(key);
        //是否在缓存中
        if(m_cacheMap.end() != iterMap){
            m_list.erase(iterMap->second);
        }
        else{
            //超出缓存大小则删除尾节点
            if(m_cacheMap.size() >= m_capacity){
                m_cacheMap.erase(m_list.back().first);
                m_list.pop_back(); 
            }
        }
        //加载数据到链表头节点
        m_list.push_front(make_pair(key,value));
        m_cacheMap[key] = m_list.begin();
    }
private:
    int m_capacity;
    list<pair<int,int>> m_list;
    map<int,list<pair<int,int>>::iterator> m_cacheMap;
};
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LRU 缓存是一种常见的缓存淘汰算法,它的设计思想是将最近最少使用的数据从缓存中淘汰出去,以保证缓存的数据都是热点数据,从而提高缓存的命中率。 下面是一个基于双向链表和哈希表实现LRU 缓存C++ 设计实现: ```cpp #include <unordered_map> struct Node { int key; int value; Node* prev; Node* next; Node(int k, int v) : key(k), value(v), prev(nullptr), next(nullptr) {} }; class LRUCache { public: LRUCache(int capacity) : size_(capacity), head_(nullptr), tail_(nullptr) {} int get(int key) { auto iter = cache_.find(key); if (iter == cache_.end()) { return -1; } else { Node* node = iter->second; move_to_head(node); return node->value; } } void put(int key, int value) { auto iter = cache_.find(key); if (iter == cache_.end()) { Node* node = new Node(key, value); add_to_head(node); cache_[key] = node; if (cache_.size() > size_) { Node* tail = remove_tail(); cache_.erase(tail->key); delete tail; } } else { Node* node = iter->second; node->value = value; move_to_head(node); } } private: int size_; Node* head_; Node* tail_; std::unordered_map<int, Node*> cache_; void add_to_head(Node* node) { if (head_ == nullptr) { head_ = node; tail_ = node; } else { node->next = head_; head_->prev = node; head_ = node; } } void move_to_head(Node* node) { if (node == head_) { return; } else if (node == tail_) { tail_ = tail_->prev; tail_->next = nullptr; } else { node->prev->next = node->next; node->next->prev = node->prev; } node->next = head_; head_->prev = node; node->prev = nullptr; head_ = node; } Node* remove_tail() { Node* node = tail_; if (head_ == tail_) { head_ = nullptr; tail_ = nullptr; } else { tail_ = tail_->prev; tail_->next = nullptr; } return node; } }; ``` 在这个实现中,我们使用了一个双向链表保存缓存中的数据,并使用一个哈希表来提高查找效率。在 `get` 操作中,如果缓存中不存在目标数据则返回 -1,否则将目标数据移到链表头部并返回其值。在 `put` 操作中,如果缓存中不存在目标数据则创建一个新的节点并将其添加到链表头部,如果缓存已满则删除链表尾部的节点。如果缓存中已存在目标数据则将其值更新并将其移动到链表头部。 需要注意的是,在 `move_to_head` 和 `remove_tail` 操作中,我们需要判断目标节点是否已经在链表的头部或尾部,以避免对空指针进行操作。此外,在每次操作中,我们还需要更新哈希表中对应节点的指针。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值