struct Node{int _key;int _value;Node* _next;Node(int key,int value,Node* next):_key(key),_value(value),_next(next){}
};class LRUCache{
public:LRUCache(int capacity) {_capacity   = capacity;_size       = 0;_last       = 0;_cur_begin  = _begin = (char *) malloc(sizeof(Node)*(capacity+1));_head       = new (_cur_begin) Node(0,0,NULL);//在指定内存上构造对象_cur_begin += sizeof(Node);}~LRUCache(){if(_begin!=NULL){while(_cur_begin > _begin){_cur_begin -= sizeof(Node);((Node*)_cur_begin)->~Node();//先释放内存上的对象
            }free(_begin);//再释放内存
        }}int get(int key) {int value             = -1;//初始时假设key对应的结点不存在
Node* pre_node_of_key = umap_prenodes[key];//key对应的结点的前驱结点if(pre_node_of_key !=NULL){//key结点存在
Node* node             = pre_node_of_key->_next;//key对应的结点pre_node_of_key->_next = node->_next;if(pre_node_of_key->_next!=NULL){umap_prenodes[pre_node_of_key->_next->_key] = pre_node_of_key;}node->_next            = _head->_next;if(node->_next!=NULL){//node有后继，更新后继的前驱结点umap_prenodes[node->_next->_key] = node;}_head->_next           = node;umap_prenodes[key]     = _head;              /*更新_last*/if(_last == key ){_last = ( pre_node_of_key == _head ? key : pre_node_of_key->_key ); }value = node->_value;}return value;}void set(int key, int value) {Node* node            = NULL;Node* pre_node_of_key = umap_prenodes[key];//key对应的结点的前驱结点if(pre_node_of_key != NULL){//key对应的结点存在，孤立key对应的结点，也就是从链表中把结点取出来，重新链接链表
node                   = pre_node_of_key->_next;//key对应的结点pre_node_of_key->_next = node->_next;if(pre_node_of_key->_next!=NULL){umap_prenodes[pre_node_of_key->_next->_key] = pre_node_of_key;//更新前驱
            }node->_value           = value; //重置结点值/*更新_last*/if(_last == key ){_last = ( pre_node_of_key == _head ? key : pre_node_of_key->_key ); }}else{//结点不存在if(_capacity == 0){//缓冲区为空return ;}if(_size == _capacity){//缓存满，重用最后一个结点
Node* pre_node_of_last    = umap_prenodes[_last];//最后一个结点的前驱结点
umap_prenodes[pre_node_of_last->_next->_key] = NULL;node                      = new (pre_node_of_last->_next) Node(key,value,NULL);//重用最后一个结点
pre_node_of_last->_next   = NULL;//移出最后一个结点
_last = ( pre_node_of_last == _head ? key : pre_node_of_last->_key ); //更新指向最后一个结点的key
}else{//缓冲未满，使用新结点
node    = new (_cur_begin) Node(key,value,NULL);_cur_begin += sizeof(Node);_size++;if(_size==1){_last = key;}}}/*把node插入到第一个结点的位置*/node->_next            = _head->_next;if(node->_next!=NULL){//node有后继，更新后继的前驱结点umap_prenodes[node->_next->_key] = node;}_head->_next           = node;umap_prenodes[key]     = _head;  }private:int   _size;int   _capacity;int   _last;//_last是链表中最后一个结点的keyNode* _head;unordered_map<int,Node*> umap_prenodes;//存储key对应的结点的前驱结点，链表中第一个结点的前驱结点为_headchar* _begin;//缓存的起始位置 char* _cur_begin;//用于分配结点内存的起始位置
};

class LRUCache{size_t m_capacity;unordered_map<int,  list<pair<int, int>>::iterator> m_map; //m_map_iter->first: key, m_map_iter->second: list iterator;list<pair<int, int>> m_list;                               //m_list_iter->first: key, m_list_iter->second: value;
public:LRUCache(size_t capacity):m_capacity(capacity) {}int get(int key) {auto found_iter = m_map.find(key);if (found_iter == m_map.end()) //key doesn't existreturn -1;m_list.splice(m_list.begin(), m_list, found_iter->second); //move the node corresponding to key to frontreturn found_iter->second->second;                         //return value of the node
    }void set(int key, int value) {auto found_iter = m_map.find(key);if (found_iter != m_map.end()) //key exists
        {m_list.splice(m_list.begin(), m_list, found_iter->second); //move the node corresponding to key to frontfound_iter->second->second = value;                        //update value of the nodereturn;}if (m_map.size() == m_capacity) //reached capacity
        {int key_to_del = m_list.back().first; m_list.pop_back();            //remove node in list;m_map.erase(key_to_del);      //remove key in map
        }m_list.emplace_front(key, value);  //create new node in listm_map[key] = m_list.begin();       //create correspondence between key and node
    }
};