运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。
    实现 LRUCache 类：

    • LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
    • int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
    • void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

    进阶：你是否可以在 O(1) 时间复杂度内完成这两种操作？
    示例：

    1. 输入
    2. ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
    3. [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
    4. 输出
    5. [null, null, null, 1, null, -1, null, -1, 3, 4]
    7. 解释
    8. LRUCache lRUCache = new LRUCache(2);
    9. lRUCache.put(1, 1); // 缓存是 {1=1}
    10. lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
    11. lRUCache.get(1);    // 返回 1
    12. lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
    13. lRUCache.get(2);    // 返回 -1 (未找到)
    14. lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
    15. lRUCache.get(1);    // 返回 -1 (未找到)
    16. lRUCache.get(3);    // 返回 3
    17. lRUCache.get(4);    // 返回 4

    解法1：VueLRU缓存策略

    1. /*
    2.  * @lc app=leetcode.cn id=146 lang=javascript
    3.  *
    4.  * [146] LRU缓存机制
    5.  */
    7. // @lc code=start
    8. /**
    9.  * @param {number} capacity
    10.  */
    11. var LRUCache = function(capacity) {
    12.     this.capacity = capacity;
    13.     this.result = {};
    14.     this.queue = [];
    15. };
    17. /** 
    18.  * @param {number} key
    19.  * @return {number}
    20.  */
    21. LRUCache.prototype.get = function(key) {
    22.     const index = this.queue.findIndex(item => item === key);
    23.     if (index === -1) return -1;
    25.     this.queue.splice(index, 1);
    26.     this.queue.unshift(key);
    27.     return this.result[key];
    28. };
    30. /** 
    31.  * @param {number} key 
    32.  * @param {number} value
    33.  * @return {void}
    34.  */
    35. LRUCache.prototype.put = function(key, value) {
    36.     const index = this.queue.findIndex(item => item === key);
    37.     if (index > -1) {
    38.         this.queue.splice(index, 1);
    39.         this.queue.unshift(key);
    40.         this.result[key] = value;
    41.     }
    42.     else{
    43.         if (this.capacity === this.queue.length) {
    44.             const lastKey = this.queue.pop();
    45.             this.result[lastKey] = undefined;
    46.         }
    48.         this.queue.unshift(key);
    49.         this.result[key] = value; 
    50.     }
    51. };
    53. /**
    54.  * Your LRUCache object will be instantiated and called as such:
    55.  * var obj = new LRUCache(capacity)
    56.  * var param_1 = obj.get(key)
    57.  * obj.put(key,value)
    58.  */
    59. // @lc code=end

    解法2：map

    1. /*
    2.  * @lc app=leetcode.cn id=146 lang=javascript
    3.  *
    4.  * [146] LRU缓存机制
    5.  */
    8. // @lc code=start
    9. /**
    10.  * @param {number} capacity
    11.  */
    12. var LRUCache = function (capacity) {
    13.     this.map = new Map();
    14.     this.capacity = capacity;
    15. };
    17. /** 
    18.  * @param {number} key
    19.  * @return {number}
    20.  */
    21. LRUCache.prototype.get = function (key) {
    22.     if (this.map.has(key)) {
    23.         const value = this.map.get(key);
    24.         this.map.delete(key);
    25.         this.map.set(key, value);
    27.         return value;
    28.     }
    30.     return -1;
    31. };
    33. /** 
    34.  * @param {number} key 
    35.  * @param {number} value
    36.  * @return {void}
    37.  */
    38. LRUCache.prototype.put = function (key, value) {
    39.     if (this.map.has(key)) {
    40.         this.map.delete(key);
    41.         this.map.set(key, value);
    42.     }
    43.     else {
    44.         if (this.capacity === this.map.size) {
    45.             const lastKey = [...this.map.keys()][0];
    46.             this.map.delete(lastKey);
    47.         }
    49.         this.map.set(key, value);
    50.     }
    51. };
    53. /**
    54.  * Your LRUCache object will be instantiated and called as such:
    55.  * var obj = new LRUCache(capacity)
    56.  * var param_1 = obj.get(key)
    57.  * obj.put(key,value)
    58.  */
    59. // @lc code=end