LeetCode146. LRU缓存机制（哈希+双向链表）
1、题目描述
https://leetcode-cn.com/problems/lru-cache/
设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。
- 获取数据 get(key) - 如果关键字 (key) 存在于缓存中，则获取关键字的值（总是正数），否则返回 -1。
- 写入数据 put(key, value) - 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字/值」。
当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
LRU 缓存淘汰算法就是一种常用策略。LRU 的全称是 Least Recently Used，最近使用过的数据应该是是「有用的」，很久都没用过的数据应该是无用的，内存满了就优先删那些很久没用过的数据。
举例，安卓手机软件的后台运行，比如先后打开了「设置」「手机管家」「日历」等应用。
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)
cache = LRUCache(2)
cache.put(1, 1) # put(key, value)
cache.put(2, 2)
# get(key), 获取关键字的值（总是正数），否则返回 -1
print(cache.get(1)) # 返回 1
cache.put(3, 3) # 该操作会使得密钥 2 作废
print(cache.get(2)) # 返回 -1 (未找到)
cache.put(4, 4) # 该操作会使得密钥 1 作废
print(cache.get(1)) # 返回 -1 (未找到)
print(cache.get(3)) # 返回 3
print(cache.get(4)) # 返回 4class LRUCache:
def __init__(self, capacity: int):
def get(self, key: int) -> int:
def put(self, key: int, value: int) -> None:2、代码详解（哈希+双向链表）
字典存k-v：用字典来存储 key-value 结构，这样对于查找操作时间复杂度就是 O(1)。
双向链表：但是因为字典本身是无序的，还需要一个类似于队列的结构来记录访问的先后顺序。这个队列需要支持如下几种操作
- 在末尾加入一项
- 去除最前端一项
- 将队列中某一项移到队首
class ListNode:
def __init__(self, key=None, value=None):
self.key = key
self.value = value
self.prev = None
self.next = None
class LRUCache:
# init函数
def __init__(self, capacity: int):
self.capacity = capacity
self.hashmap = {} # 用字典来存储 key-value，查找操作O(1)
# 新建两个节点 head 和 tail
self.head = ListNode()
self.tail = ListNode()
# 初始化链表为 head <-> tail
self.head.next = self.tail
self.tail.prev = self.head
# 因为get与put操作都可能需要将双向链表中的某个节点移到头部(变成最新访问的)
# 子方法：将该节点移到链表头部
def move_node_to_header(self, key):
# (1)先将哈希表key指向的节点拎出来，为了简洁起名node
# hashmap[key] hashmap[key]
# | |
# V --> V
# prev <-> node <-> next pre <-> next ... node
node = self.hashmap[key]
node.prev.next = node.next # prev -> next
node.next.prev = node.prev # prev <- next
# (2)之后将node插入到头部节点前
# hashmap[key] hashmap[key]
# | |
# V --> V
# header <-> next ... node header <-> node <-> next
node.prev = self.head # head <- node
node.next = self.head.next # node -> next
self.head.next.prev = node # node <- next
self.head.next = node # head -> node
# 子方法：在头部插入节点new
def add_node_to_header(self, key, value):
new = ListNode(key, value)
self.hashmap[key] = new
# head <-> new <-> head.next
new.prev = self.head # head <- new
new.next = self.head.next # new -> head.next
self.head.next.prev = new # new <- head.next
self.head.next = new # head -> new
# 子方法：删除尾结点(若cache容量已满)
def pop_tail(self):
last_node = self.tail.prev
# 去掉链表尾部的节点在哈希表的对应项
self.hashmap.pop(last_node.key)
# 去掉最久没有被访问过的节点，即尾部Tail之前的一个节点
# last_node.prev - last_node - tail
last_node.prev.next = self.tail
self.tail.prev = last_node.prev
# last_node.prev <-> tail
return last_node
# get,O(1)
def get(self, key: int) -> int:
if key in self.hashmap:
# 如果已经在链表中了就把它移到头部（变成最新访问的）
self.move_node_to_header(key)
res = self.hashmap.get(key, -1)
if res == -1:
return res
else:
return res.value
# put,O(1)
def put(self, key: int, value: int) -> None:
if key in self.hashmap:
# 如果key本身已经在哈希表中了就不需要在链表中加入新的节点
# 但是需要更新字典该值对应节点的value
self.hashmap[key].value = value
# 之后将该节点移到链表头部
self.move_node_to_header(key)
else:
if len(self.hashmap) >= self.capacity:
# 若cache容量已满，删除cache中最不常用的节点
self.pop_tail()
self.add_node_to_header(key, value)
https://leetcode-cn.com/problems/lru-cache/solution/shu-ju-jie-gou-fen-xi-python-ha-xi-shuang-xiang-li/
https://leetcode-cn.com/problems/lru-cache/solution/lru-ce-lue-xiang-jie-he-shi-xian-by-labuladong/