方法一:哈希表 + 双向链表
LRU 缓存机制可以通过哈希表辅以双向链表实现,我们用一个哈希表和一个双向链表维护所有在缓存中的键值对。
双向链表按照被使用的顺序存储了这些键值对,靠近头部的键值对是最近使用的,而靠近尾部的键值对是最久未使用的。
哈希表即为普通的哈希映射(HashMap),通过缓存数据的键映射到其在双向链表中的位置。
这样以来,我们首先使用哈希表进行定位,找出缓存项在双向链表中的位置,随后将其移动到双向链表的头部,即可在 O(1) 的时间内完成 get 或者 put 操作。
解题思路:
我们设计一个最近最少使用缓存策略/机制时,需要实现以下两操作:
1、获取元素:如果元素在缓存中,则返回其值,否则返回-1.
2、插入元素:如果元素不在缓存中,则插入该元素。当缓存达到其容量时,删除最近最少使用的元素。
LRUcache成员变量包括当前使用的大小size、容量capacity、缓存元素cache、头结点head和为节点tail。
LRUcache定义头结点和尾节点,是为了维护一个双向链表,用于记录每个节点的访问顺序,从而实现LRU缓存的淘汰策略。
DLinkNode表示一个双向链表节点,成员变量包括键值对key和value,以及前驱节点prev和或后继节点next。
DLinkNode定义的是一个节点的结构,用于在链表中存储每个元素的信息。可以将DLinkNode看作是LRUcache中维护双链表中的一个节点。
时间复杂度:O( 1)
- Get 方法的时间复杂度为 O(1),因为直接通过 map 获取缓存元素,同时将该元素移到链表的头部也只需要常数级别的时间复杂度。
- Put 方法的时间复杂度为 O(1)。如果没有达到缓存容量限制,则同时需要移动节点、增加节点等操作,也只需要常数级别的时间复杂度。
空间复杂度:O(n + capacity )
- map 的缓存元素的个数为 O(n),
- 双向链表的缓存容量 capacity 为 O(capacity)
- 因此,总的空间复杂度为 O(n + capacity)。
type LRUCache struct{
size int
capacity int
cache map[int]*DLinkedNode //缓存里的元素/键的key和value
head,tail *DLinkedNode
}
//定义一个双链表的结构体,还未初始化
type DLinkedNode struct{
key,value int
prev,next *DLinkedNode
}
func main(){
//cache.Get(2)
// 创建一个容量为 2 的缓存实例
cache := Constructor(2)
// 向缓存中添加键值对 1:1,没有返回值
cache.Put(1, 1)
// 向缓存中添加键值对 2:2,没有返回值
cache.Put(2, 2)
// 获取键为 1 的值,期望返回值为 1
fmt.Println(cache.Get(1))
// 向缓存中添加键值对 3:3,没有返回值
cache.Put(3, 3)
// 获取键为 2 的值,期望返回值为 -1(因为之前已经从缓存中删除过键 2)
fmt.Println(cache.Get(2))
// 向缓存中添加键值对 4:4,没有返回值
cache.Put(4, 4)
// 获取键为 1 的值,期望返回值为 -1(因为之前已经从缓存中删除过键 1)
fmt.Println(cache.Get(1))
// 获取键为 3 的值,期望返回值为 3
fmt.Println(cache.Get(3))
// 获取键为 4 的值,期望返回值为 4
fmt.Println(cache.Get(4))
}
//初始化双链表的结构体
func initDLinkedNode(key,value int) *DLinkedNode{
return &DLinkedNode{
key: key,
value: value,
}
}
//constructor是LRUCache的构造函数,用来初始化LCUcache结构体
func Constructor(capacity int)LRUCache{
l:=LRUCache{
cache: map[int]*DLinkedNode{},
head: initDLinkedNode(0,0),
tail: initDLinkedNode(0,0),
capacity: capacity,
}
l.head.next=l.tail//定义l的头结点头指针指向l的尾节点
l.tail.prev=l.head
return l
}
//Get方法获取缓存中制定key对应的value。
func (this *LRUCache)Get(key int) int{
if _,ok:=this.cache[key];!ok{
return -1
}
node :=this.cache[key]//新建一个node节点来接键的值value
this.moveToHead(node)//取完key的值value后,将该node节点放到双链表的头结点位置
return node.value
}
//Put方法讲一个key-value键值对添加到缓存中。
func(this *LRUCache)Put(key int,value int){
if _,ok:=this.cache[key];!ok{
node:=initDLinkedNode(key,value)
this.cache[key]=node//把node节点放入缓存
this.addToHead(node)//把node节点放到头结点
this.size++//缓存使用大小加1
if this.size>this.capacity{
removed:=this.removeTail()
delete(this.cache,removed.key)
this.size--
}
//else表示缓存里已经有了该key的value,Put函数会先更新这个key对应的节点的值
//然后将这个节点移到双链表的头部,即最近使用过的位置,以及更新最近使用时间
}else{
node := this.cache[key]
node.value = value
this.moveToHead(node)
}
}
func (this *LRUCache)addToHead(node *DLinkedNode){
node.prev=this.head
node.next=this.head.next
//要把node节点放在头节点和头结点的下一节点之间
this.head.next.prev=node//this.head.next.prev头结点的下一节点的prev指针指向node
this.head.next=node//this.head.next 头结点的next指针指向node
}
//moveToHead方法将一个节点移动到双链表的头部。
func (this *LRUCache)moveToHead(node *DLinkedNode){
this.removeNode(node)//把node节点删除
this.addToHead(node)//node节点插入到头结点位置
}
//removeNode方法将一个节点从双向链表中移除。
func(this *LRUCache)removeNode(node *DLinkedNode){
node.prev.next=node.next
node.next.prev=node.prev
}
//removeTail方法移除双向链表的尾部节点,并返回该节点。
func (this *LRUCache)removeTail()*DLinkedNode{
//尾节点并不实际存有数据,尾节点是为了方便直到它的前一节点是什么,方便更新上一节点的next指针
node:=this.tail.prev//删除的是尾节点的前一个节点
this.removeNode(node)
return node
}