LRU系列（146. LRU 缓存）——链表

"""
请你设计并实现一个满足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
 

提示：

1 <= capacity <= 3000
0 <= key <= 10000
0 <= value <= 105
最多调用 2 * 105 次 get 和 put
"""

"""
本题题解：本题的核心是使用了双向链表和哈希表；其中，链表具有删除和插入的时间辅助度为O(1),哈希表的查找时间复杂度为0(1),
因此，考虑使用哈希表+双向链表，里面核心设计如下：
哈希表记录了key与node（双向列表节点）的映射关系
双向链表记录了操作的序列信息（具有时序性）
1）为什么使用双向链表
我们可以把链表想象成队列，当需要删除的元素位于队尾，其他查找的元素放置在对头，如果是单向列表，我们删除队尾的元素，需要遍历整个链表，因此需要双向链表

2）链表为什么需要有key和value的值，只要value的值不行吗？
不行，当内存占满后，删除末尾的链表，同时也需要删除哈希表的key的记录，因此，需要根据删除节点，反推key的信息
"""

"""
定义双向链表节点实列
"""
class DNode(object):
    def __init__(self, key=0, val=0):
        self.key = key
        self.val = val
        self.next = None
        self.prev = None


"""
对双向链表操作的封装
"""
class DoubleLinkedList(object):
    def __init__(self):
        self.size = 0
        self.head = DNode()
        self.tail = DNode()
        self.head.next = self.tail
        self.tail.prev = self.head

    #添加元素到双向链表， 先定义该节点的指向信息，然后，定义前后指针对他的指向
    def add_to_head(self, node):
        node.prev = self.head #前指针指向头节点
        node.next = self.head.next #后指针指向头节点的下一个节点
        self.head.next.prev = node# 头节点的下一个节点的前指针指向node
        self.head.next = node #头指针的下一个指针指向node
        self.size += 1

    #删除当前元素
    def remove_node(self, node):
        node.next.prev = node.prev
        node.prev.next = node.next
        self.size -= 1

    #将该节点移动到头节点
    def moveToHead(self, node):
        self.remove_node(node)
        self.add_to_head(node)

    #删除尾节点
    def remove_tail(self):
        node = self.tail.prev
        self.remove_node(node)
        return node

class LRUCache(object):
    def __init__(self, capacity):
        self.cap = capacity
        self.double_list = DoubleLinkedList() #初始化双向链表
        self.cache = dict() #初始化哈希表

    """
    先判断该key值是否存在，如果不存在，则返回-1
    反之，先利用哈希表，查找到该node, 返回这个节点的val
    同时，将这个节点移动到第一位
    """
    def get(self, key):
        if key not in self.cache:
            return -1
        node = self.cache.get(key)
        self.double_list.moveToHead(node)
        return node.val

    """
    判断key是否存在，如果存在，先查找到这个node，并重双向链表中删除这个节点，并将新节点插入到表头，并更新哈希表的值
    如果不存在，则有两种情况，1）链表未满，直接将节点插入表头并更新哈希表；2）新删除表尾的元素，再将节点插入表头并更新哈希表；
    """
    def put(self, key, value):
        new_node = DNode(key=key, val=value)
        if key in self.cache:
            node = self.cache.get(key)
            self.double_list.remove_node(node)
        else:
            if self.double_list.size == self.cap:
                delete_node = self.double_list.remove_tail()
                self.cache.pop(delete_node.key)
        self.double_list.add_to_head(new_node)
        self.cache[key] = new_node