146.LRU缓存

 解题思路：

我们设计一个最近最少使用缓存策略/机制时，需要实现以下两操作：

1、获取元素：如果元素在缓存中，则返回其值，否则返回-1.

2、插入元素：如果元素不在缓存中，则插入该元素。当缓存达到其容量时，删除最近最少使用的元素。

LRUcache成员变量包括当前使用的大小size、容量capacity、缓存元素cache、头结点head和为节点tail。

LRUcache定义头结点和尾节点，是为了维护一个双向链表，用于记录每个节点的访问顺序，从而实现LRU缓存的淘汰策略。

DLinkNode表示一个双向链表节点，成员变量包括键值对key和value，以及前驱节点prev和或后继节点next。

DLinkNode定义的是一个节点的结构，用于在链表中存储每个元素的信息。可以将DLinkNode看作是LRUcache中维护双链表中的一个节点。

接下来定义了一些方法：包括：

Constructor(capacity int) LRUCache：构造函数，返回一个 LRU Cache

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 initDLinkedNode(key,value int) *DLinkedNode{
	return &DLinkedNode{
		key: key,
		value: value,
	}
}
//constructor是LRUcache的构造函数，用来初始化LRUcache结构体
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
}