leetcode 146 LRU C++ 实现

LRU :

1、整体使用哈希双向链表，

哈希用于快速找到需要处理的链表节点

链表用于表示各个节点的顺序

  LRU (最近最少使用) 缓存机制 。

 

class Node
{
public:
    int key,value;
    Node *next,*pre;
    Node(int k, int v)
    {
        key = k;
        value = v;
    }
};

struct DoubleList
{
private:
    Node *head,*tail;
    int size;
public:
    DoubleList()
    {
        head = new Node(0,0);
        tail = new Node(0,0);
        head->next = tail;
        tail->pre = head;
        size = 0;
    }
    void addLast(Node *x)
    {
        x->pre = tail->pre;
        x->next = tail;
        tail->pre->next = x;
        tail->pre = x;
        size++;
    }
    void remove(Node *x)
    {
        x->pre->next = x->next;
        x->next->pre = x->pre;
        size--;
    }
    Node *removeFrist()
    {
        if(head->next == tail)
        {
            return NULL;
        }
        Node *frist = head->next;
        remove(frist);
        return frist;
    }
    int getSize()
    {
        return size;
    }


};
class LRUCache {
private:
    unordered_map<int,Node*> map;
    DoubleList cache;
    int cap;
    void makeRecently(int key)
    {
        Node *x = map[key];
        cache.remove(x);
        cache.addLast(x);
    }
    void addRecently(int key, int val)
    {
        Node *x = new Node(key,val);
        cache.addLast(x);
        map[key] =x;
    }
    void deleteKey(int key)
    {
        Node *x = map[key];
        cache.remove(x);
        map.erase(key);
    }
    void removeLeastRecently()
    {
        Node  *deleteNode = cache.removeFrist();
        map.erase(deleteNode->key);
    }
public:
    LRUCache(int capacity) {
        cap = capacity;
    }
    
    int get(int key) {
        if(map.count(key) > 0)
        {
            makeRecently(key);
            return map[key]->value;
        }
        return -1;

    }
    
    void put(int key, int value) {
        if(map.count(key) > 0)
        {
            deleteKey(key);
            addRecently(key,value);
            return;
        }
        if(cap == cache.getSize())
            removeLeastRecently();
        addRecently(key,value);


    }
};