算法日记本 | LeetCode 146. LRU缓存机制

题目描述

运用你所掌握的数据结构，设计和实现一个 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

分析解答

LRU 是内存管理中一种经典的页面置换算法，它的关键点在于找出最近最少使用的页面，比如说对于一个页面我们有存储、访问和更新三种操作，三种操作都算是 “该页面被使用了” ，那么经过一段时间之后，每个页面都会有一个 “最后一次被使用的时间” ，LRU 算法的关键就是要找出 “最后一次被使用的时间最早” 的那个页面。

好吧，我承认可能说的有点绕了。说白了，其实就是要找到最“老”的那个页面嘛（这里我们统一用页面来指代题目中的数据，比较直观些）。因此我们需要维护页面的顺序，可以维护一个队列，让最近被使用的页面处于最前端，这样当缓存容量到达上限，只需要删除最后一个页面即可。这里有个比较麻烦的点，当随机访问一个缓存中的页面后，这个页面可能处于队列中的任意位置，而因为它被访问了，所以需要将它移到队列的最前端。这里就有一个随机访问的操作，结合题目中 O(1) 时间复杂度的要求，我们很容易想到需要使用哈希表来帮忙。

结合上面的分析，我们可以维护一个有序的双向链表和一个从key到页面的映射表，对于get(key) ，根据映射表找到节点，返回value，同时更新链表，把该节点移动到最前端。使用双向链表是为了可以方便地找到节点两边的节点，从而将他们重新链接起来。对于put(key, value)操作，如果容量未达上限，直接将新节点插入链表头部，同时更新映射表即可。否则，先删除链表尾部的节点，再执行插入操作即可。

按照上述方法编写的代码如下：

class LRUCache(object):
    def __init__(self, capacity):
        """
        :type capacity: int
        """
        self.capacity = capacity
        self.size = 0
        self.double_list = DoubleList()
        self.mapping = dict()

    def get(self, key):
        """
        :type key: int
        :rtype: int
        """
        target_node = self.mapping.get(key, None)
        if target_node is not None:
            result = target_node.value
            self.double_list.delete(target_node)
            self.double_list.insert(target_node)
            return result
        else:
            return -1

    def put(self, key, value):
        """
        :type key: int
        :type value: int
        :rtype: None
        """
        target_node = self.mapping.get(key, None)
        if target_node is not None:
            target_node.value = value
            self.double_list.delete(target_node)
            self.double_list.insert(target_node)
        else:
            if self.size == self.capacity:
                temp_key = self.double_list.delete_tail_node()
                self.size -= 1
                del self.mapping[temp_key]
            new_node = ListNode(key=key, value=value)
            self.mapping[key] = new_node
            self.double_list.insert(new_node)
            self.size += 1


class ListNode(object):
    def __init__(self, key=None, value=None):
        self.left_pointer = None
        self.right_pointer = None
        self.key = key
        self.value = value

    def get_value(self):
        return self.value


class DoubleList(object):
    def __init__(self):
        self.head = ListNode()
        self.tail = ListNode()
        self.head.right_pointer = self.tail
        self.tail.left_pointer = self.head

    def insert(self, target_node):
        # 在链表开头插入新节点
        second_node = self.head.right_pointer
        target_node.right_pointer = second_node
        target_node.left_pointer = self.head
        self.head.right_pointer = target_node
        second_node.left_pointer = target_node

    def delete(self, target_node):
        # 删除指定的节点
        front_node = target_node.left_pointer
        behind_node = target_node.right_pointer
        front_node.right_pointer = behind_node
        behind_node.left_pointer = front_node
        target_node.left_pointer = None
        target_node.right_pointer = None

    def delete_tail_node(self):
        # 删除在队尾的节点
        target_node = self.tail.left_pointer
        key = target_node.key
        self.delete(target_node)
        return key

点击提交，一次通过，超过了 85% 的提交记录！手写的链表性能还是不错的嘛，嘿嘿！

今天就分享到这里啦，下期再见哦！

---

以上就是本文的全部内容，如果您喜欢这篇文章，欢迎将它分享给朋友们。

感谢您的阅读，祝您生活愉快！

作者：小美哥
2019-03-15