【146】LRU缓存机制

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。
实现 LRUCache 类：

LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

进阶：你是否可以在 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

思考：关键是处理好插入操作，当插入后保证已有的数据有序，当已有数据达到capacity后，我们选择最久没有“使用”过得数字删除。由于数据保存是使用key value形式的，也就是用字典保存，如何保证字典有序，用链表保存顺序信息。python里面是没有链表的。通过手动实现一个双向链表进行保存。（方法2）或者使用直接使用collections.OrderDict(方法1)。

方法一：

from collections import OrderedDict
class LRUCache(object):def __init__(self, capacity):""":type capacity: int"""self.capacity = capacityself.orderdict = OrderedDict()def get(self, key):""":type key: int:rtype: int"""if key not in self.orderdict:return -1res = self.orderdict[key]self.orderdict.pop(key)self.orderdict[key] = resreturn resdef put(self, key, value):""":type key: int:type value: int:rtype: None"""if key in self.orderdict:self.orderdict.pop(key)if len(self.orderdict)==self.capacity:self.orderdict.popitem(False)        self.orderdict[key] = value        # Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)

注：关于collection.OrderedDict链表字典的使用：

保证插入的数据有序，同时可以弹出头部和尾部元素。

from collections import OrderedDicta = OrderedDict()
a['a'] = 1
a['b'] = 2
a['c'] = 3
a.popitem(False)# 弹出最早插入的元素 OrderedDict([('b', 2), ('c', 3)])
a.popitem()# 弹出最早插入的元素 OrderedDict([('a', 1), ('b', 2)])#######################
######################popitem()实现源码##########def popitem(self, last=True):'''od.popitem() -> (k, v), return and remove a (key, value) pair.Pairs are returned in LIFO order if last is true or FIFO order if false.'''if not self:raise KeyError('dictionary is empty')key = next(reversed(self) if last else iter(self))value = self.pop(key)return key, value

方法二：

对于保证有序的问题，可以手动实现一个双向链表。get() put()操作后都将访问的元素放在链表的头部，用链表的操作是这里有很多插入删除操作，数组需要多次搬移。同时维护一个字典，保存key-node形式。node为链表中的节点。

为了更快找到头、尾。链表的头和尾单独保存。例如移动到头部可以立刻找到位置，删除尾部元素也可以o(1)找到。

class NodeList(object):def __init__(self,key=0,val=0):self.key = keyself.val = valself.pre = Noneself.next = Noneclass LRUCache(object):    def __init__(self, capacity):""":type capacity: int"""self.cache = {}self.capacity = capacityself.size = 0self.head = NodeList()self.tail = NodeList()self.head.next = self.tailself.tail.pre = self.headdef get(self, key):""":type key: int:rtype: int"""if key not in self.cache:return -1self.moveTohead(self.cache[key])return self.cache[key].valdef put(self, key, value):""":type key: int:type value: int:rtype: None"""if key not in self.cache:node = NodeList(key,value)self.addTohead(node)self.cache[key] = nodeself.size+=1if self.size>self.capacity:node = self.removeTail()self.cache.pop(node.key)self.size-=1else:oldnode = self.cache[key]             oldnode.val = valueself.moveTohead(oldnode)def removeNode(self,node):node.pre.next = node.nextnode.next.pre = node.predef addTohead(self,node):node.pre = self.headnode.next = self.head.nextself.head.next.pre = nodeself.head.next = node        def moveTohead(self,node):self.removeNode(node)self.addTohead(node)def removeTail(self):node = self.tail.preself.removeNode(node)return node# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)

【146】LRU缓存机制相关推荐

146. LRU 缓存机制
146. LRU 缓存机制运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制 . 实现 LRUCache 类: LRUCache(int capacity) 以正整数作为容量 ...
Java实现 LeetCode 146 LRU缓存机制
146. LRU缓存机制运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制.它应该支持以下操作: 获取数据 get 和写入数据 put . 获取数据 get(key) - ...
Leetcode 146. LRU缓存机制【哈希表 [哈希表存储每个元素在双向链表中的指针]+双向链表】
文章目录问题描述解题报告实验代码参考资料问题描述运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制.它应该支持以下操作: 获取数据 get 和写入数据 put . ...
146. LRU缓存机制
运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制.它应该支持以下操作: 获取数据 get 和写入数据 put . 获取数据 get(key) - 如果密钥 (key) 存 ...
LeetCode 146. LRU缓存机制（哈希链表）
文章目录 1. 题目信息 2. 解题 2.1 手动实现list 2.2 使用内置list 1. 题目信息运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制.它应该支持以下操作 ...
LeetCode —— 146. LRU缓存机制（Python）
运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制.它应该支持以下操作: 获取数据 get 和写入数据 put . 获取数据 get(key) - 如果关键字 (key) 存 ...
[leetcode]146. LRU缓存机制
1.LRU(最近最少使用)缓存机制: https://baike.baidu.com/item/LRU/1269842?fr=aladdin 2.用到的数据结构: struct Value {int ...
【LeetCode】146. LRU缓存机制
题目描述运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制. 它应该支持以下操作:获取数据 get 和写入数据 put . 获取数据 get(key) - 如果密钥 (key ...
2021-11-26Leetcode 146.LRU缓存机制
struct DLinkedNode{int key,value;//key代表某一个进程的页,而value代表页中的数据值DLinkedNode*prev;//前面的节点DLinkedNode*ne ...
C++实现LRU算法（LeetCode 146 LRU缓存机制）
LRU算法: LRU算法(Least Recently Used)是一种缓存淘汰策略,最近使用的数据是有用的, 如果缓存满了,删除最久没用过的数据 LRU算法描述: (1)设置缓存大小 (2)get: ...

【146】LRU缓存机制

【146】LRU缓存机制相关推荐

最新文章

热门文章