数据结构LRUCache(Least Recently Used – 最近最少使用缓存)

题目要求：

   设计一个数据结构，实现LRU Cache的功能(Least Recently Used – 最近最少使用缓存)。它支持如下2个操作： get 和 put。
   int get(int key) – 如果key已存在，则返回key对应的值value（始终大于0）；如果key不存在，则返回-1。
   void put(int key, int value) – 如果key不存在，将value插入；如果key已存在，则使用value替换原先已经存在的值。如果容量达到了限制，LRU Cache需要在插入新元素之前，将最近最少使用的元素删除。
   请特别注意“使用”的定义：新插入或获取key视为被使用一次；而将已经存在的值替换更新，不算被使用。
   限制：请在O(1)的时间复杂度内完成上述2个操作。

输入描述

   第一行读入一个整数n，表示LRU Cache的容量限制。 从第二行开始一直到文件末尾，每1行代表1个操作。
   如果每行的第1个字符是p，则该字符后面会跟随2个整数，表示put操作的key和value。
   如果每行的第1个字符是g，则该字符后面会跟随1个整数，表示get操作的key。

输出描述

   按照输入中get操作出现的顺序，按行输出get操作的返回结果。

示例：

输入：
2
p 1 1
p 2 2
g 1
p 2 102
p 3 3
g 1
g 2
g 3
输出：
1
1
-1
3

解题思路：

   put(key,value)在O(1)的时间内完成，可以使STD中的一个容器：双端链表list，由于list没有实现[]操作符重载，为了实现O(1)内查找，可以使用另一个容器：ordered_map。每次“使用”元素的时候，就将该元素调整到链表的首部，这样当超出容量的时候，直接删除链表末尾的元素及其在map中对应的值。

list介绍：

   list是一种序列式容器。
   list容器完成的功能实际上和双向链表极其相似，list中的数据元素是通过链表指针串连成逻辑意义上的线性表，也就是list也具有链表的主要优点，即：在链表的任一位置进行元素的插入、删除操作都是快速的。
   由于list元素节点并不要求在一段连续的内存中，显然在list中是不支持快速随机存取的，因此对于迭代器，只能通过“++”或“–”操作将迭代器移动到后继/前驱节点元素处。而不能对迭代器进行+n或-n的操作，这点，是与vector等不同的地方。

begin() #返回一个指向容器起始位置的iterator
rbegin() #返回list中末尾的迭代器
end()  #返回list末端下一位置的iterator
push_back() #插入元素到list的末尾
push_front() #从list的头部插入元素
empty()  #判断list是否为空
resize() #调用resize(n)将list的长度改为只容纳n个元素，超出的元素将被删除，如果需要扩展那么调用默认构造函数T()将元素加到list末端。如果调用resize(n,val)，则扩展元素要调用构造函数T(val)函数进行元素构造，其余部分相同
clear() #清空list中的所有元素
front() #返回list容器中的头部元素引用
back() #返回list容器的最后一个元素的引用
pop_back() #删除链表的末尾元素
pop_front() #删除链表的首部元素
swap() #交换两个链表,list1,swap(list2)和swap(list1,list2)都可以实现list1和list2的交换
splice() #实现链表拼接
/**
将源list的内容部分或全部元素删除，拼插入到目的list，有三种函数声明
dest_list.splice(iterator position,list& source_list) #将source_list的所有元素剪接到dest_list的position的后面
dest_list.splice(iterator position,list& source_list, iterator it)#将source_list的it位置处的元素剪接到dest_list的position的后面
dest_list.splice(iterator position,list& source_list, iterator first,iterator last)#将source_list的first到last的元素剪接到dest_list的position后面

##测试
#include
#include 
using namespace std;
int main()
{
	listlist1,list2;
	for(int i=1;i<=4;i++) {
		list1.push_back(i);
		list2.push_back(i+10);
	}
	// list1 1 2 3 4
	// list2 11 12 13 14
	list::iterator it=list1.begin();
	it++;
	list1.splice(it,list2);//1 11 12 13 14 2 3 4
	if(list2.empty()) cout<<"list2 is empty"<::iterator it=list1.begin();it!=list1.end();++it) cout<<*it<<"  ";
	cout<::iterator it=list2.begin();it!=list2.end();++it) cout<<*it<<"  ";
	cout< > list3;
	for(i=1;i<=3;i++)
		list3.push_back(make_pair(i,i+3));
	list >::iterator iter=list3.begin();
	cout<first<<" "<second<

unordered_map介绍

1、与map的区别

   map的内部实现是红黑树（红黑树是一种严格的平衡二叉搜索树），因此该容器具有自动排序的功能，map内部的所有元素都是有序的。对map的所有操作都是基于红黑树，因此很多操作都可以在O(logn)的时间内完成，map适用于对元素顺序有要求的场合。
   缺点：由于红黑树的节点需要保存节点指针和数据域，所以红黑树的空间开销比较大。
   unorder_map的内部实现是哈希表，并且使用开放链表寻址法解决冲突问题，因此元素的查找速度可以达到O(1)，适用于对于查找操作有较高才做的场合。
   缺点：哈希表的时间复杂度比较高。

2、使用

find(key) #返回key所对应的迭代器，如果该迭代器与end()相等，说明map中不存在key。
count(key) #返回key在map中出现的次数，如果为0说明key不在map中
iterator erase(const_iterator pos ) #移除map中pos处键值对
iterator erase(const_iterator first, const_iterator last );#移除map中first到last的键值对
size_type erase(const key_type& key )#移除特定key的键值对。
begin() 　　#返回指向容器起始位置的迭代器
end() 　　   #返回指向容器末尾位置的迭代器 
cbegin()　   #返回指向容器起始位置的常迭代器（const_iterator） 
cend() 　　 #返回指向容器末尾位置的常迭代器 
insert()  　　#插入元素 
/**
unordered_map的迭代器是一个指针，指向这个元素，通过迭代器来取得它的值。
unordered_map::iterator it;
(*it).first;             // the key value (of type Key)
(*it).second;            // the mapped value (of type T)
(*it);                   // the "element value" (of type pair) 
it->first;               // 同 (*it).first   (the key value)
it->second;              // 同(*it).second  (the mapped value) 
**/

实现代码：

#include 
#include 
#include 
#include 
#include 
using namespace std;
class LRUCache{
private:
	int cap;
	list> L;
	unordered_map>::iterator> m;
public:
	LRUCache(int capacity){
		cap=capacity;
	}
	int get(int key){
		auto it=m.find(key);
		if(it == m.end()) return -1;
		L.splice(L.begin(),L,it->second);
		return it->second->second;
	}
	void put(int key,int value){
		auto it=m.find(key);
		if(it != m.end()) {
            it->second->second=value;
        }else{
            L.push_front(make_pair(key,value));
            m[key]=L.begin();
        }
		if(m.size() > cap){
			int k=L.rbegin()->first;
			L.pop_back();
			m.erase(k);
		}
	}
};
int main(){
    int n;
    cin>>n;
    LRUCache L(n);
    string cmd;
    char commond;
    while(getline(cin,cmd)){
        istringstream iss(cmd);
        iss>>commond;
        if(commond=='p'){
            int key,val;
            iss>>key>>val;
            L.put(key,val);
        }else if(commond=='g'){
            int key;
            iss>>key;
            int val=L.get(key);
            cout<

注意

   按行读取输入，每一行的输入通过getline(cin,cmd)读入到cmd中，然后通过istringstream iss(cmd)构造一个字符串输入流，然后从中解析出字符、整数。