146. LRU 缓存

方法一：哈希表 + 双向链表

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
}