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