通过双向链表加HashMap实现LRU
1.先实现一个Node节点类
class Node{
int key;
int val;
Node pre;
Node next;
public Node(int key,int val){
this.key = key;
this.val = val;
this.pre = null;
this.next = null;
}
}
再接着实现双向链表
class DoubleList{
Node head;
Node tail;
public DoubleList(){
head = new Node(-1,-1);
tail = new Node(-1,-1);
head.next = tail;
tail.pre = head;
}
public void addFirst(Node node){
node.next = head.next;
head.next.pre = node;
node.pre = head;
head.next = node;
}
public void delete(Node node){
node.pre.next = node.next;
node.next.pre = node.pre;
}
public int deleteLast(){
if(tail.pre==head){
//如果没有节点 则删除失败
return -1;
}
Node node = tail.pre;
int key = node.key;
this.delete(node);
return key;
}
}
之后在LRU类中 通过调用Doublelist 并创建HashMap实现LRU机制
class LRUCache {
HashMap<Integer,Node> hm;//key 为int val 为Node 节点
DoubleList dl;
int capacity;
public LRUCache(int capacity) {
hm = new HashMap();
dl = new DoubleList();
this.capacity = capacity;
}
public int get(int key) {
if(!hm.containsKey(key)){
return -1;
}
//如果存在 则把该节点删除 再重新加入LRU中
Node node = hm.get(key);
this.put(key,node.val);
return node.val;
}
public void put(int key, int value) {
Node node = new Node(key,value);
if(hm.containsKey(key)){
//重复直接删掉
dl.delete(hm.get(key));
}else if(hm.size()==capacity){
// 满了 则删除最后一个,同时更新HashMap;
int k = dl.deleteLast();
hm.remove(k);
}
//最后加入到最前面,并更新HashMap
dl.addFirst(node);
hm.put(key,node);
}
}