2018.12.3——第七天-优快云博客

本文探讨了LRU缓存算法的实现，采用哈希表存储数据，包括flag、value和frequency，确保O(1)时间复杂度下完成get和put操作。作者分享了一个具体的C++实现案例，但在测试中遇到了未预期的问题。

题目

继续实现类，这次也是比较好理解并实现的类：LRU缓存

需要设置一个存储使用次数的数组，来决定哪个数据将被替换

基础要求总体来说难度不高，但是不得不说 O(1) 的确有难度，值得挑战一下。

用哈希表，存储为flag，value,frequency,可不用循环直接找到

实现

class LRUCache {
public:
        int size;
        int store[3][10000];
        int min[2];
        int max;
    LRUCache(int capacity) {
        size=0;
        min[0]=0;
        memset(store[0],0,40000);
        int max=capacity;
    }
    
    int get(int key) {
        if(store[0][key]==1){
            store[2][key]++;
            if(store[2][key]<min[0]){
                min[0]=store[2][key];
                min[1]=key;
            }
            return store[1][key];
        }
            return -1;
    }
    
    void put(int key, int value) {
        if(size<max){
            store[0][key]=1;        //flag
            store[1][key]=value;    //nums
            store[2][key]=0;        //frequency
            size++;
            min[0]=0;
            min[1]=key;
        }
        else{
            store[0][min[1]]=0;
            store[1][min[1]]=value;
            store[2][min[1]]=0;
            
            store[0][key]=1;        
            store[1][key]=value;   
            store[2][key]=0;    
            min[0]=0;
            min[1]=key;
        }
            
        
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */