LSGO——LeetCode实战（链表系列）：146题 LRU缓存机制(LUR Cache)

原题：

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。

进阶:

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

示例:

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1); // 返回 1
cache.put(3, 3); // 该操作会使得密钥 2 作废
cache.get(2); // 返回 -1 (未找到)
cache.put(4, 4); // 该操作会使得密钥 1 作废
cache.get(1); // 返回 -1 (未找到)
cache.get(3); // 返回 3
cache.get(4); // 返回 4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lru-cache
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法一：

思路：
创建一个类似于队列的结构记录访问的先后顺序，该队列需要支持一下操作：

• 在末尾加入一项
• 去除最前端一项
• 将队列中某一项移到末尾
  使用双链表去记录key和value，在创建一个hashmap去搜索节点（O(1)时间复杂度)，当搜索到了节点，利用链表结构进行上述操作。

# 新建一双链表,存储关键词和value值
class ListNode:
    def __init__(self, key = None, value = None):
        """
        :type capacity: int
        """
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache(object):
    def __init__(self, capacity):
        """
        :type capacity: int
        """
        self.capacity = capacity
        self.hashmap ={} 
        # 新建两个节点，head和tail
        self.head = ListNode()
        self.tail = ListNode()
        # 初始化链表为head <-> tail
        self.head.next = self.tail
        self.tail.prev = self.head
    
    def move_node_to_tail(self,key):
        node = self.hashmap[key]
        # 将node拿出来
        node.prev.next = node.next
        node.next.prev = node.prev
        # 将node节点插入到尾节点前
        node.prev = self.tail.prev
        node.next = self.tail
        self.tail.prev.next = node
        self.tail.prev = node
        
    def get(self, key):
        """
        :type key: int
        :rtype: int
        """
        if key in self.hashmap:
            self.move_node_to_tail(key)
        res = self.hashmap.get(key,-1)
        if res == -1:
            return res
        else:
            return res.value

    def put(self, key, value):
        # 写入数据
        """
        :type key: int
        :type value: int
        :rtype: None
        """
        # 如果关键词在哈希表
        if key in self.hashmap:
            self.hashmap[key].value = value  # 更新vale值
            self.move_node_to_tail(key)   # 将节点移动到尾节点的prev位置
        else:
            # 如果缓存已满，去掉哈希表对应项
            if len(self.hashmap) == self.capacity:
                self.hashmap.pop(self.head.next.key)
                # 去掉最久没有被访问过的节点，即头节点之后的节点
                self.head.next = self.head.next.next
                self.head.next.prev = self.head
            # 如果不在的话就插入到尾节点前
            new = ListNode(key, value)  # 初始化一个节点
            self.hashmap[key] = new   # 添加进哈希表
            new.prev = self.tail.prev
            new.next = self.tail
            self.tail.prev.next = new
            self.tail.prev = new