请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。
实现 LRUCache 类：
LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。
函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。
示例：
输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]
解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4
关键思路：
解题思路：巧用 Map 数据结构
首先明确一个性质，Map 这个 ES6 新增数据结构是 ==有序的==，即不仅可以存储键值对(关键字-值)，还可以通过 delete 和 set 的 API 对数据进行更新，最后 se==t 的数据默认在 Map 的末尾==。
因此利用好上面的性质，这题其实非常容易了，对于题目的 第二点 和 第三点 要求，在每次 get 和 put 已存在队列中的值，或新增值，直接 delete 删掉后，再 set 进行更新到 Map 最后即可(最新)
算法流程
初始化：
初始化一个 Map 数据结构，和一个容量 capacity
对于 get：如果没有该关键字就返回 -1，如果有，那就先 get 获取该关键字对应的值后，再进行更新(更新的方法是先 delete 该关键字，然后再 set 重新加入到 map 末尾)
对于 put 新增 键值对(关键字-值)：直接 set 新增到 map 末尾即可 更新 已存在的键值对(关键字-值)：先 delete 该关键字，然后再 set 重新加入到 map 末尾的方法进行更新到最新访问状态
当然，put 同时还有判断是否超出缓存容量 capacity，超了就得删除，或更新原有键值对 那么经过上述的操作，一直没有被更改的(即最近最少使用)，就会慢慢移动到了 map 的头部，所以当遇到 缓存队列满 的情况时，直接将 队头移出 即可，而这只会发生在 put 这个 API
争议
// put 后判断是否超载
if(this.map.size > this.capacity){
this.map.delete(this.map.keys().next().value);
}
对于上面代码可能会有争议，是放在 put 之前还是之后？
如果放在 put 后面，就简单了很多，put 之后判断 map.size() 是不是大过规定的容量即可，大于就将头部移出 this.map.delete(this.map.keys().next().value)
而如果放在 put 前面，也就是先判断是否缓存满了 this.map.size === this.capacity，再进行后续的 新增/更新，其实挺麻烦的，因为缓存满的话也不能立刻移出队头
如果新加入的键值对是队列中已存在的，那就只是更新到 map 尾部即可
如果不存在，也就是要新增键值对，才需要移出头部
要是单单看上述的分析，毫无疑问选择第一种，put 后再判断是否超出缓存
但要是结合实际场景其实第一种不合适的，我设置一个缓存队列，都已经满了你还塞进来？？肯定得先删一个才能塞进来新的是吧
所以我建议解题 为了方便 用第一种即可(先 put 再判断是否超出)，而如果面试官问起，或者要 结合具体场景，推荐第二种(先判断再 put)
解：
/**
* @param {number} capacity
*/
var LRUCache = function (capacity) {
this.map = new Map();
this.len = capacity;
};
/**
* @param {number} key
* @return {number}
*/
LRUCache.prototype.get = function (key) {
if (this.map.has(key)) {
let _value = this.map.get(key);
this.map.delete(key);
this.map.set(key, _value);
return _value;
} else {
return -1;
}
};
/**
* @param {number} key
* @param {number} value
* @return {void}
*/
LRUCache.prototype.put = function (key, value) {
// 如果已有，那就要更新，即要先删了再进行后面的 set
if (this.map.has(key)) {
this.map.delete(key)
}
this.map.set(key, value);
// put 后判断是否超载
if (this.len < this.map.size) {
this.map.delete(this.map.keys().next().value);
}
};
/**
* Your LRUCache object will be instantiated and called as such:
* var obj = new LRUCache(capacity)
* var param_1 = obj.get(key)
* obj.put(key,value)
*/
Map知识拓展：
关键点，Map键值是插入排序的。
有一个细节问题，.next()是什么作用？
没错，是迭代器。
（1）执行next后会从上往下依次返回每个[yield]表达式的值，
（2）如果next有传参的话，会整个覆盖掉将要返回当前yield的上一个yield，
（3）方法内的yield[表达式]和return都执行完了，就会直接返回undefined了。
**新的遍历方法：entries()，keys()和values()**
keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。
let a = [1,3,5].keys();
a; // 一个迭代器对象
a.next(); // {value: 0, done: false}
a.next(); // {value: 1, done: false}
a.next(); // {value: 2, done: false}
a.next(); // {value: undefined, done: true}
———— 前端、Javascript实现、算法、刷题、leetcode
