C++ 实现LRU缓存机制

实现方法：hashmap+双向链表。

我们用一个哈希表和一个双向链表维护所有在缓存中的键值对。

双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。

哈希表即为普通的哈希映射（HashMap），通过缓存数据的键映射到其在双向链表中的位置。

这样以来，我们首先使用哈希表进行定位，找出缓存项在双向链表中的位置，随后将其移动到双向链表的头部，即可在 O(1)的时间内完成 get 或者 put 操作。具体的方法如下：

对于 get 操作，首先判断 key 是否存在：
- 如果 key 不存在，则返回 -1。
- 如果 key 存在，则 key 对应的节点是最近被使用的节点。通过哈希表定位到该节点在双向链表中的位置，并将其移动到双向链表的头部，最后返回该节点的值。
对于 put 操作，首先判断 key 是否存在：
- 如果 key 不存在，使用 key 和 value 创建一个新的节点，在双向链表的头部添加该节点，并将 key 和该节点添加进哈希表中。然后判断双向链表的节点数是否超出容量，如果超出容量，则删除双向链表的尾部节点，并删除哈希表中对应的项；
- 如果 key 存在，则与 get 操作类似，先通过哈希表定位，再将对应的节点的值更新为 value，并将该节点移到双向链表的头部。

上述各项操作中，访问哈希表的时间复杂度为 O(1)，在双向链表的头部添加节点、在双向链表的尾部删除节点的复杂度也为 O(1)。而将一个节点移到双向链表的头部，可以分成「删除该节点」和「在双向链表的头部添加节点」两步操作，都可以在 O(1) 时间内完成。

细节：在双向链表的实现中，使用一个伪头部（dummy head）和伪尾部（dummy tail）标记界限，这样在添加节点和删除节点的时候就不需要检查相邻的节点是否存在。

struct Node
{
    int key;
    int value;
    Node* pre;//前继指针
    Node* next;//后继指针
    Node():key(-1),value(-1),pre(nullptr),next(nullptr){}
    Node(int mkey,int mval):key(mkey),value(mval),pre(nullptr),next(nullptr){}
};

class LRUCache {
private:
    unordered_map<int,Node*> cache;
    Node* head;//双向链表的头结点
    Node* tail;//双向链表的尾节点
    int size;//LRU的当前大小
    int capacity;//LRU的最大容量
public:
    LRUCache(int capacity) {
        head = new Node();
        tail = new Node();
        head->next = tail;
        tail->pre = head;
    }
    
    int get(int key) {
        if(!cache.count(key))//如果当前key不存在
        {
            return -1;
        }
        //当前key存在
        Node* cur = cache[key];
        moveTohead(cur);//将当前节点移动到头部
        return cur->value;
    }
    
    void put(int key, int value) {
        if(!cache.count(key))//如果要存入的key->value不存在
        {
            Node* node = new Node(key,value);
            cache[key] = node;//记得把当前的key存入到hashmap中去，方便查找
            addTohead(node);//将当前节点移动到头部
            ++size;
            if(size > capacity)//如果当前缓存满了，则要淘汰尾节点
            {
                Node* cur = removeTail();//返回尾节点
                cache.erase(cur->key);//记得将hashmap中的key和对应的Node也删除掉
                delete cur;//释放尾节点所占用的空间
                --size;
            }
        }
        else//对应的key->value已存在，更新key对应的value，并且移动到头部
        {
            Node* node = cache[key];
            node->value = value;
            moveTohead(node);
        }
    }

    void moveTohead(Node* node)//将node移动到头部
    {
        removeNode(node);
        addTohead(node);
    }

    void removeNode(Node* node)
    {
        node->pre->next = node->next;
        node->next->pre = node->pre;
    }

    void addTohead(Node* node)
    {
        node->pre = head;
        node->next = head->next;
        head->next->pre = node;
        head->next = node;
    }

    Node* removeTail()
    {
        Node* node = tail->pre;
        removeNode(node);
        return node;
    }


};

C++ 实现LRU缓存机制

猜你喜欢