1.leetcode原题链接:. - 力扣(LeetCode)
2.题目描述
请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。
实现 LRUCache
类:
LRUCache(int capacity)
以 正整数 作为容量capacity
初始化 LRU 缓存int get(int key)
如果关键字key
存在于缓存中,则返回关键字的值,否则返回-1
。void put(int key, int value)
如果关键字key
已经存在,则变更其数据值value
;如果不存在,则向缓存中插入该组key-value
。如果插入操作导致关键字数量超过capacity
,则应该 逐出 最久未使用的关键字。
函数 get
和 put
必须以 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
提示:
1 <= capacity <= 3000
0 <= key <= 10000
0 <= value <= 105
- 最多调用
2 * 105
次get
和put
3.实现方法
思路:使用哈希加双向链表
1.定义一个Node类,用于存放数据
2.定义一个双向链表,里面存放Node
2.1 双向链表的构造
2.2 双向链表的方法1:把新节点添加到头中(addToHead)
2.3 双向链表的方法2:删除当前节点(removeNode)
2.4 双向链表的方法3:获取最后一个节点(getLast)
return tail.prev
3.根据key从缓存获取value(get)
3.1当前key不存在,返回-1
3.2 其它,双向链表删除当前节点并添加到头节点,返回value
4.向缓存添加数据(put)
4.1 若存在当前key,替换value值并放回map中,双向链表删除当前节点并添加到头节点
4.2.1 容量满了,map和双向链表删除尾节点
4.2.2 map放入要添加的Node,并把新Node放到双向链表的头节点
class LRUCache {
//1.构建一个Node节点,存储数据
class Node<K,V>{
K key;
V value;
Node<K,V> next;
Node<K,V> prev;
public Node(){}
public Node(K key,V value){
this.key=key;
this.value=value;
}
}
//2 构建一个虚拟的双向链表,里面存放的是Node
class DoubleLinkedList<K,V>{
Node<K,V> head;
Node<K,V> tail;
//2.1 构造方法
public DoubleLinkedList(){
head=new Node();
tail=new Node();
head.next=tail;
tail.prev=head;
}
//2.2 添加到头
public void addToHead(Node<K,V> node){
node.next=head.next;
node.prev=head;
head.next.prev=node;
head.next=node;
}
//2.3 删除节点
public void removeNode(Node<K,V> node){
node.next.prev=node.prev;
node.prev.next=node.next;
node.next=null;
node.prev=null;
}
//2.4 获取最后一个节点
public Node getLast(){
return tail.prev;
}
}
private int capacity;
Map<Integer,Node<Integer,Integer>> map;
DoubleLinkedList<Integer,Integer> doubleLinkedList;
public LRUCache(int capacity) {
this.capacity=capacity;
map=new HashMap();
doubleLinkedList=new DoubleLinkedList();
}
public int get(int key) {
// 当前key不存在,返回-1
if(!map.containsKey(key)){
return -1;
}
//其它,双向链表删除当前节点并添加到头节点,返回value
Node<Integer,Integer> node=map.get(key);
doubleLinkedList.removeNode(node);
doubleLinkedList.addToHead(node);
return node.value;
}
public void put(int key, int value) {
//存在当前key,替换value值并放回map中
//双向链表删除当前节点并添加到头节点
if(map.containsKey(key)){
Node<Integer,Integer> node= map.get(key);
node.value=value;
map.put(key,node);
doubleLinkedList.removeNode(node);
doubleLinkedList.addToHead(node);
}else{
//容量满了,map和双向链表删除尾节点
if(map.size()== capacity){
Node<Integer,Integer> node=doubleLinkedList.getLast();
map.remove(node.key);
doubleLinkedList.removeNode(node);
}
//map放入要添加的Node,并把新Node放到双向链表的头节点
Node<Integer,Integer> newNode=new Node<>(key,value);
map.put(key,newNode);
doubleLinkedList.addToHead(newNode);
}
}
}