LRUCachede

主题：

时间复杂度O（1）实现LRUCache的Get（）和Put（）函数

环境：

C++17

思路：

使用C++17的unordered_map来构建Hash映射，list来存储实际数据

原理：

• unordered_map即是hash_map，通过牺牲内存构建一个hash表来实现根据key值快速O（1）获取value值，且这里的value值存储的是list的迭代器

• list用于存储实际的数据，底层实现是双向链表，这里设计的是链表头到尾数据从最新被访问过到最旧被访问过的数据

代码如下：

Lrucache.h ：

#ifndef _LRU_CACHE_H_
#define _LRU_CACHE_H_

#include 
#include 

template 
class LRUCache{
public:
    typedef typename std::pair pair_t;
    typedef typename std::list::iterator list_it;

    /**
     * @brief 构造函数
     * @param size 缓存容量
     */
    LRUCache(size_t size){
        cache_size = size;
    }

    /**
    * @brief  判断某个key值数据是否存在
    * @param  key
    * @return 存在-true 不存在-false
    */
    size_t exist(const key_t& key){
        return cache_map.find(key)!=cache_map.end();
    }

    /**
     *
     * @return 当前缓存已使用大小
     */
    size_t size(){
        return cache_list.size();
    }

    /**
     * @brief 插入新数据
     * @param key
     * @param value
     */
    void put(const key_t& key,const value_t& value){
        // 先判断缓存中是否已经存在该key值
        auto it = cache_map.find(key);
        if(it != cache_map.end()){
            // 若存在,则删除原有数据
            cache_list.erase(it->second);
            cache_map.erase(it);
        }
        // 再判断缓存是否已满
        if(cache_map.size() >= cache_size){
            // 若满，删除最近最少使用一项的map索引和list数据
            auto last = cache_list.end();
            last--;
            cache_map.erase(last->first);
            cache_list.pop_back();
        }
        // 将新数据插入链表首部
        cache_list.push_front(pair_t(key,value));
        // 添加map索引
        cache_map[key] = cache_list.begin();
    }

    /**
     * @brief  获取相应key值的数据
     * @param  key
     * @return
     */
    value_t get(const key_t& key){
        // 先判断缓存中是否已经存在该key值
        auto it = cache_map.find(key);
        if(it == cache_map.end()){
            // 若不存在，则抛出异常
            throw "There are not such key in cache!";
        }
        else{
            // 若存在，则使用list的拼接函数将当前使用数据移动到list首部
            cache_list.splice(cache_list.begin(),cache_list,it->second);
            return it->second->second;
        }
    }

private:
    int cache_size;                               // 缓存容量
    std::list cache_list;                 // 双向链表负责维护访问先后顺序的信息与实际数据
    std::unordered_map cache_map;  // hash_map负责存储数据索引
};

#endif

测试代码

test.cpp ：

#include 
#include "Lrucache.h"

int main(){
    std::cout << "LRUCache testing" << std::endl;
    std::cout << "Create a cache sizeof 5" << std::endl;
    LRUCache cache(5);
    std::cout << "Now put (1,one),(2,two),(3,three),(4,four) into the cache " << std::endl;
    cache.put(1,"one");
    cache.put(2,"two");
    cache.put(3,"three");
    cache.put(4,"four");
    std::cout << "After put four datas,the cache size = " << cache.size() << std::endl;
    std::cout << "Now put (5,five) into the cache " << std::endl;
    cache.put(5,"five");
    std::cout << "After put five datas,whether key=1 is exists :" << (cache.exist(1)?"true":"false") << std::endl;
    std::cout << "Now put (6,six) into the cache " << std::endl;
    cache.put(6,"six");
    std::cout << "After put six datas,whether key=1 is exists :" << (cache.exist(1)?"true":"false") << std::endl;
    std::cout << "                    whether key=2 is exists :" << (cache.exist(2)?"true":"false") << std::endl;
    std::cout << "                    whether key=3 is exists :" << (cache.exist(3)?"true":"false") << std::endl;
    std::cout << "                    whether key=4 is exists :" << (cache.exist(4)?"true":"false") << std::endl;
    std::cout << "                    whether key=5 is exists :" << (cache.exist(5)?"true":"false") << std::endl;
    std::cout << "                    whether key=6 is exists :" << (cache.exist(6)?"true":"false") << std::endl;
    std::string str = "null";
    if(cache.exist(3))
        str = cache.get(3);
    std::cout << "Check the cache data ,eg : key=3 value=" << str << std::endl;
    return 0;
}

运行方法

在C++17机器上执行

# g++ test.cpp -o test
# ./test

运行结果如下