LRU 缓存结构

题目描述
设计LRU缓存结构，该结构在构造时确定大小，假设大小为K，并有如下两个功能
set(key, value)：将记录(key, value)插入该结构
get(key)：返回key对应的value值
[要求]
set和get方法的时间复杂度为O(1)
某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。
当缓存的大小超过K时，移除最不经常使用的记录，即set或get最久远的。
若opt=1，接下来两个整数x, y，表示set(x, y)
若opt=2，接下来一个整数x，表示get(x)，若x未出现过或已被移除，则返回-1
对于每个操作2，输出一个答案
示例1
输入
复制
[[1,1,1],[1,2,2],[1,3,2],[2,1],[1,4,4],[2,2]],3
返回值
复制
[1,-1]
说明
第一次操作后：最常使用的记录为(“1”, 1)
第二次操作后：最常使用的记录为(“2”, 2)，(“1”, 1)变为最不常用的
第三次操作后：最常使用的记录为(“3”, 2)，(“1”, 1)还是最不常用的
第四次操作后：最常用的记录为(“1”, 1)，(“2”, 2)变为最不常用的
第五次操作后：大小超过了3，所以移除此时最不常使用的记录(“2”, 2)，加入记录(“4”, 4)，并且为最常使用的记录，然后(“3”, 2)变为最不常使用的记录

#include<unordered_map>
struct Node {
    
    
    int key,val;
    Node * pre;
    Node * next;
    Node(int k,int v):key(k),val(v),pre(NULL),next(NULL) {
    
    };
};


class Solution {
    
    
public:
    ~Solution() {
    
    
        Node* pre = head;
        while (pre) {
    
    
            Node *q = pre;
            pre = pre->next;
            delete q;
        }
    }
    int size=0;
    Node *head,*tail;
    unordered_map<int,Node*> _map;
    /**
     * lru design
     * @param operators int整型vector<vector<>> the ops
     * @param k int整型 the k
     * @return int整型vector
     */
    void moveToHead(Node *node) {
    
    
        if(node==NULL||node->pre == head) return;
        if(node->pre)node->pre->next = node->next;
        if(node->next) node->next->pre = node->pre;
        //insert to head after
        node->pre = head;
        node->next = head->next;
        head->next->pre = node;
        head->next = node;
        
    }
    void removeLast() {
    
    
        _map.erase(this->tail->pre->key);
        tail->pre->pre->next = tail;
        Node* x = tail->pre;
        tail ->pre = tail->pre->pre;
        delete x;
    }
    void set(int k,int val) {
    
    
        if(_map.find(k)== _map.end()) {
    
    
            Node* node = new Node(k,val);
            _map[k] = node;
            if(this->size<=0) {
    
    
                removeLast();//容量不足
            }else{
    
    
                this->size--;
                
            }
            node->pre = head;
            node->next = head->next;
            head->next->pre = node;
            head->next = node;
            
        }else{
    
    
            _map[k]->val = val;
            moveToHead(_map[k]);
        }
    }
    int get(int key) {
    
    
        int res = -1;
        if(_map.find(key)!=_map.end()) {
    
    
            moveToHead(_map[key]);
            return _map[key]->val;
        }
        return res;
    }
    
    vector<int> LRU(vector<vector<int> >& operators, int k) {
    
    
        // write code here
        if (k<=0) return {
    
    };
        this->size = k;
        this ->head = new Node(0,0);
        this ->tail = new Node(0,0);
        this ->head ->next = tail;
        this->tail ->pre = this->head;
        vector<int>res;
        for (vector<int>&sub: operators) {
    
    
            if(sub[0]==1) {
    
    
                //set
                set(sub[1],sub[2]);
            }else {
    
    
                //get(x)
                res.push_back(get(sub[1]));
            }
        }
        return res;
        
    }
};