leetcode 模拟内存LRU

LRU，最近最少使用的内存单元。

可以使用一个链表来维护内存单元的使用顺序，最近使用的放在最后，最远使用的放在头部。

这样，每次使用一个节点的时候，我们就把他从链表中取出，放在最后，没有的话就直接插入在最后。

为了快速的找到在链表中的位置，我们需要用一个平衡树。

为了方便的维护链表（删除），我们需要使用双向链表。

为了方便，在一开始的时候就在双向链表前后各插入一个节点，这样tail 和 head 就不会出事情了。

最近在使用 leetcode 维护代码能力。。

#include <stdio.h>
#include <iostream>
#include <queue>
#include <algorithm>
#include <map>
#include <vector>
#include <cmath>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <fstream>
#include <set>
#include <stack>
#include <list>
using namespace std;

#define READ freopen("acm.in","r",stdin)
#define WRITE freopen("acm.out","w",stdout)
#define ll long long
#define ull unsigned long long 
#define uint unsigned int
#define PII pair<int,int>
#define PDD pair<double,double>
#define fst first
#define sec second
#define MS(x,d) memset(x,d,sizeof(x))
#define INF 1000001000
#define ALL(x) x.begin(),x.end()
#define PB push_back
#define MOD 99991
#define MAX 11111

struct node
{
    int key;
    int value;
    node *next;
    node *before;
    node()
    {
        next=before=NULL;
    }
    node(int k,int v)
    {
        key=k;
        value=v;
        next=before=NULL;
    }
};
class LRUCache{
    map<int,node*> kv;
    int cap;
    node *tail;
    node *head;
public:

    LRUCache(int capacity) {
        cap=capacity;
        head=new node;
        tail=new node;
        head->next=tail;
        tail->before=head;
    }
    
    int get(int key) {
        if(kv.find(key)==kv.end())
            return -1;
        int ret=kv[key]->value;
        update(key);
        return ret;
    }
    void update(int key)
    {
        node *p=kv[key];
        kv.erase(kv.find(key));
        add(p->key,p->value);
        del(p);
    }
    void add(int key,int value)
    {
        node *p=new node(key,value);
        node *b=tail->before;
        b->next=p;
        p->before=b;
        p->next=tail;
        tail->before=p;
        kv[key]=p;
    }

    void del(node *p)
    {
        node *b=p->before;
        b->next=p->next;
        p->next->before=p->before;
        delete p;
    }

    void set(int key, int value) {
        if(kv.find(key)!=kv.end())
            kv[key]->value=value,update(key);
        else
        {
            if(kv.size()==cap)
            {
                node *p=head->next;
                kv.erase(kv.find(p->key));
                del(p);
            }
            add(key,value);
        }
    }

};