算法:LRU缓存机制

题目：

解决方法：

源码分析：

//节点定义
struct DLinkedNode
{
        int key, value; //节点在hash表里的键值和值
        DLinkedNode*  prev;     //此节点的前驱节点
        DLinkedNode*  next;     //此节点的后继节点
        DLinkedNode() :key(0), value(0), prev(nullptr), next(nullptr) {} //构造函数，赋值key和value
        DLinkedNode(int _key, int _value) :key(_key), value(_value), prev(nullptr), next(nullptr) {} //带参构造函数（重载）
};
 
//LRU 缓存类
class LRUCache {
private:
        unordered_map<int, DLinkedNode*> cache; //哈希映射表 
        DLinkedNode* head; //双向链表头结点
        DLinkedNode* tail; //双向链表尾结点
        int size; //当前节点个数
        int capacity; //LRU缓存最大节点个数（容量）
 
public:
        LRUCache(int _capacity) :capacity(_capacity), size(0){
                head = new DLinkedNode(); //哨兵节点，形成环形链表
                tail = new DLinkedNode();
                head->next = tail;
                tail->prev = head;
        }
        
   //获取数据
        int get(int key){
      //判断是否缓存命中
                if (!cache.count(key)){
                        return -1;
                }
                                            
      //因为最近访问了，所以移到链表最前端
                DLinkedNode* node = cache[key];
                moveToHead(node);
                return node->value;
        }
        
   //插入数据
        void put(int key, int value){
      //如果缓存未命中，则创建新的节点，插入哈希，移到链表头部（最近访问数据）
      //缓存区满的话，要移除链表尾部节点，因为是最久未访问的数据
                if (!cache.count(key)){
                        DLinkedNode* node = new DLinkedNode(key, value);
                        cache[key] = node;
                        addToHead(node);
                        ++size;
 
                        if (size > capacity){
                                DLinkedNode* removed = removeTail();
                                cache.erase(removed->key);
                                delete removed;
                                --size;
                        }
                }
                else{
                        //取到此节点
                        DLinkedNode* node = cache[key];
                        //赋值新值
                        node->value = value;
                        //移到链表头部，变为最近访问的数据
                        moveToHead(node);
                }
        }
 
private:
        void addToHead(DLinkedNode* node){
                node->prev = head;
                node->next = head->next;
                head->next->prev = node;
                head->next = node;
        }
 
        void removeNode(DLinkedNode* node){
                node->prev->next = node->next;
                node->next->prev = node->prev;
        }
        
   //移动节点到头部
        void moveToHead(DLinkedNode* node){
                //移除掉此节点
                removeNode(node);
                //最近访问数据放到头部
                addToHead(node);
        }
        
   //移除尾部节点
        DLinkedNode* removeTail(){
                DLinkedNode* node = tail->prev;
                removeNode(node);
                return node;
        }
};
 
/*
测试数据：
#include<iostream>
#include<unordered_map>
using namespace std;
 
int main(){
        LRUCache* lRUCache = new LRUCache(2);
        lRUCache->put(1, 1); // 缓存是 {1=1}
        lRUCache->put(2, 2); // 缓存是 {1=1, 2=2}
        lRUCache->get(1);    // 返回 1
        lRUCache->put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
        lRUCache->get(2);    // 返回 -1 (未找到)
        lRUCache->put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
        lRUCache->get(1);    // 返回 -1 (未找到)
        lRUCache->get(3);    // 返回 3
        lRUCache->get(4);    // 返回 4
 
        system("pause");
        return 0;
}
*/