题目
运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作: 获取数据 get 和 写入数据 put 。
获取数据 get(key) - 如果密钥 (key) 存在于缓存中,则获取密钥的值(总是正数),否则返回 -1。
写入数据 put(key, value) - 如果密钥已经存在,则变更其数据值;如果密钥不存在,则插入该组「密钥/数据值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。
进阶:
你是否可以在 O(1) 时间复杂度内完成这两种操作?
示例:
LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1); // 返回 1
cache.put(3, 3); // 该操作会使得密钥 2 作废
cache.get(2); // 返回 -1 (未找到)
cache.put(4, 4); // 该操作会使得密钥 1 作废
cache.get(1); // 返回 -1 (未找到)
cache.get(3); // 返回 3
cache.get(4); // 返回 4
理解
题目要求在O(1)的空间复杂度实现,最初并没有想到,只是有一个大概的感觉要用hashmap来存储key和对应的元素的位置,并且每次取出要更新一下当前位置。
这里设想,如果用普通的数组同时hashmap存储数组的下标,这样每次更新一个值,hashmap中所有的值都要更新,操作就太复杂了,于是选择采用链表的实现,既然要随意的删除元素和插入元素,因此选择双向链表,操作方便,同时hashmap中存储key与链表节点,(链表节点包含了所需要的位置信息,可以直接存)。
于是先定义一个双向链表的类
class doubleNode{
int key;
int value;
doubleNode pre;
doubleNode next;
doubleNode(int key, int value){
this.key = key;
this.value = value; //最开始复制的太潇洒,吧value直接复制成了key,一直错误
}
}
于是就先定义三个函数,
- 双向链表中的删除函数
void reMoveOne(doubleNode cur){
cur.pre.next = cur.next;
cur.next.pre = cur.pre;
}
- 将某一个节点放置链表头
void moveToTop(doubleNode cur){
reMoveOne(cur);
cur.next = head.next;
cur.pre = head;
head.next.pre = cur;
head.next = cur;
}
- 删除链表尾函数
doubleNode deletTail(){
doubleNode temp = fina.pre;
reMoveOne(temp);
return temp;
}
完整代码如下
import java.util.*;
class LRUCache {
class doubleNode{
int key;
int value;
doubleNode pre;
doubleNode next;
doubleNode(int key, int value){
this.key = key;
this.value = value;
}
}
private Map<Integer, doubleNode> cache = new HashMap<Integer, doubleNode>();
private int capacity;
private int size;
doubleNode head ;
doubleNode fina ;
public LRUCache(int capacity) {
this.capacity = capacity;
head = new doubleNode(-1,-1);
fina = new doubleNode(-1,-1);
head.next = fina;
fina.pre = head;
size = 0;
}
public int get(int key) {
doubleNode cur = cache.get(key);
if(cur == null){
return -1;
}
moveToTop(cur);
return cur.value;
}
public void put(int key, int value) {
if(cache.get(key)!=null){
doubleNode cur = cache.get(key);
cur.value = value;
moveToTop(cur);
}else{
doubleNode temp = new doubleNode(key, value);
cache.put(key, temp);
addTohead(temp);
size ++;
}
if(size > capacity){
doubleNode temp = deletTail();
cache.remove(temp.key); //两个表, 要删一起删
size--;
}
}
void reMoveOne(doubleNode cur){
cur.pre.next = cur.next;
cur.next.pre = cur.pre;
}
void addTohead(doubleNode cur){
cur.next = head.next;
cur.pre = head;
head.next.pre = cur;
head.next = cur;
}
void moveToTop(doubleNode cur){
reMoveOne(cur);
addTohead(cur);
}
doubleNode deletTail(){
doubleNode temp = fina.pre;
reMoveOne(temp);
return temp;
}
}
/**
* Your LRUCache object will be instantiated and called as such:
* LRUCache obj = new LRUCache(capacity);
* int param_1 = obj.get(key);
* obj.put(key,value);
*/