LintCode-LRU缓存策略

为最近最少使用(LRU)缓存策略设计一个数据结构,它应该支持以下操作:获取数据(get)和写入数据(set)。

获取数据get(key):如果缓存中存在key,则获取其数据值(通常是正数),否则返回-1。

写入数据set(key, value):如果key还没有在缓存中,则写入其数据值。当缓存达到上限,它应该在写入新数据之前删除最近最少使用的数据用来腾出空闲位置。

您在真实的面试中是否遇到过这个题?  Yes
样例
标签 
Expand  

相关题目 
Expand 

分析:题目看起来蛮简单的,但是实现起来很多细节都需要考虑到,主要是链表的操作,获取数据可以用哈希表来加速,然后已经在的一些数据用双链表来存,head表示最新的数据,tail表示最旧的数据,每次get或者set都要把相应的数据放到head上

代码:

struct Node
{
    Node(int _key,int _value){key = _key;value = _value;pre = next = NULL;}
    int key;
    int value;
    Node*pre;
    Node*next;
};
class LRUCache{
public:
    // @param capacity, an integer
    LRUCache(int capacity) {
        // write your code here
        this->capacity = capacity;
        size = 0;
        head = NULL;
        tail = NULL;
    }
    
    // @return an integer
    int get(int key) {
        // write your code here
        if(m.find(key)==m.end())
        {
            return -1;
        }
        else
        {
            Node* n = m[key];
            int ret = n->value;
            if(head!=n)
            {
                if(n==tail)
                    tail = tail->pre;
                Node*pre = n->pre;
                if(n->next!=NULL)
                    n->next->pre = pre;
                pre->next = n->next;
                n->next = head;
                head->pre = n;
                head = n;
            }
            return ret;
        }
    }

    // @param key, an integer
    // @param value, an integer
    // @return nothing
    void set(int key, int value) {
        // write your code here
        if(head==NULL)
        {
            head = new Node(key,value);
            tail = head;
            size++;
            m[key] = head;
            return;
        }
        if(m.find(key)==m.end())
        {
            Node*n = new Node(key,value);
            n->next = head;
            head->pre = n;
            head = n;
            m[key] = n;
            size++;
        }
        else
        {
            Node*n = m[key];
            if(head!=n)
            {
                if(n==tail)
                    tail = tail->pre;
                Node*pre = n->pre;
                pre->next = n->next;
                if(n->next!=NULL)
                    n->next->pre = pre;
                n->next = head;
                head->pre = n;
                head = n;
                m[key] = n;
            }
            head->value = value;
        }
        if(size>capacity)
        {
            Node*todel = tail;
            int keyToDel = todel->key;
            tail = tail->pre;
            tail->next = NULL;
            delete todel;
            m.erase(m.find(keyToDel));
            size--;
        }
        
    }
    
    private:
        int capacity;
        int size;
        Node*head;
        Node*tail;
        unordered_map<int,Node*> m;
};

虽然思想简单,但还是建议大家写一写,能避免面试里踩进很多坑

    原文作者:LintCode题目解答
    原文地址: https://blog.csdn.net/wangyuquanliuli/article/details/47357805
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞