请你设计并实现一个满足 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) 的平均时间复杂度运行。

    使用用map存放，方便查找，key为key,value为双向链表的节点。
    使用双向链表，方便删除和添加节点。

    1. class ListNode {
    2.     constructor(key, value) {//双向链表的单个节点
    3.         this.key = key
    4.         this.value = value
    5.         this.next = null //指向后一个节点
    6.         this.prev = null //指向前一个节点
    7.     }
    8. }
    10. class LRUCache {
    11.     constructor(capacity) {
    12.         this.capacity = capacity //容量
    13.         this.hashTable = {} //存放键值对信息
    14.         this.count = 0 //键值对数量
    15.         this.dummyHead = new ListNode() //dummy头节点 方便在链表从开始的地方插入
    16.         this.dummyTail = new ListNode()    //dummy尾节点 方便在链表从末尾删除
    17.         this.dummyHead.next = this.dummyTail //dummyHead和dummyTail相互连接
    18.         this.dummyTail.prev = this.dummyHead
    19.     }
    21.     get(key) {
    22.         let node = this.hashTable[key]//查找哈希表中的键值对
    23.         if (node == null) return -1 //不存在该键值对 返回-1
    24.         this.moveToHead(node) //移动到链表头
    25.         return node.value
    26.     }
    28.     put(key, value) {
    29.         let node = this.hashTable[key] //哈希表中查找该键值对
    30.         if (node == null) {
    31.             let newNode = new ListNode(key, value) //不存在就创建节点
    32.             this.hashTable[key] = newNode //加入哈希表
    33.             this.addToHead(newNode) //加入链表头
    34.             this.count++ //节点数+1
    35.             if (this.count > this.capacity) { //超过容量 从队尾删除一个
    36.                 this.removeLRUItem()
    37.             }
    38.         } else {
    39.             node.value = value //键值对存在于哈希表中 就更新
    40.             this.moveToHead(node) //移动到队头
    41.         }
    42.     }
    44.     moveToHead(node) {
    45.         this.removeFromList(node)//从链表中删除节点
    46.         this.addToHead(node)//将该节点添加到链表头
    47.     }
    49.     removeFromList(node) {//删除的指针操作
    50.         let tempForPrev = node.prev
    51.         let tempForNext = node.next
    52.         tempForPrev.next = tempForNext
    53.         tempForNext.prev = tempForPrev
    54.     }
    56.     addToHead(node) {//加入链表头的指针操作
    57.         node.prev = this.dummyHead
    58.         node.next = this.dummyHead.next
    59.         this.dummyHead.next.prev = node
    60.         this.dummyHead.next = node
    61.     }
    63.     removeLRUItem() {
    64.         let tail = this.popTail()//从链表中删除
    65.         delete this.hashTable[tail.key]//从哈希表中删除
    66.         this.count--
    67.     }
    69.     popTail() {
    70.         let tailItem = this.dummyTail.prev//通过dummyTail拿到最后一个节点 然后删除
    71.         this.removeFromList(tailItem)
    72.         return tailItem
    73.     }
    74. }