LeetCode 之 LRU Cache解决思路

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations:

get

and

set

.

get(key)

- Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.

set(key, value)

- Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

这道题主要是实现“最近最少使用替换”算法。

Cache的大小是有限的，当增加新的值时，如果没有额外空间，就需要采用替换算法。替换算法的核心就是要维护一个状态，即：哪个值应该被替换出去，哪个值是最新的。

同时当调用get方法时，需要更新刚索引过的值，将其状态设置为最新，再更新其他值的状态，最近最少使用的那个值将更新为：下次被替换出去。set方法同样需要更新各个值的状态。

根据上述的分析，我们可以采用单向链表来实现该替换算法。该链表需要维护一个尾指针。我们将最新状态的值放置在尾部，最近最少使用的值放在头部。当没有额外空间时，加入新值，我们在尾部添加，同时删除头部的旧值。当更新值得状态时，对应的操作就是链表的删除和插入操作。

但是链表的缺点就是遍历耗时。如何在O(1)时间内访问到链表中的值呢？可以结合Hash表的性质。hash表内存储节点的key值和节点的指针。当调用get方法时，利用hashMap获取到包含该key的节点，时间为O(1)。此时，需要做的就是要维护hashmap和链表的一致性。

import java.util.HashMap;

public class LRUCache {
private LinkList list;

public LRUCache(int capacity) {
list = new LinkList(capacity);
}

public int get(int key) {
return list.get(key);
}

public void set(int key, int value) {
list.set(key, value);
}

public void print(){
list.printList();
}

class LinkList{
private int capacity;//链表总长度
private int size;//当前链表节点个数
private Node head;//头指针
private Node tail;//尾指针
private HashMap<Integer, Node> map;

public LinkList(int capacity){
this.capacity = capacity;
this.size = 0;
head = new Node();
tail = head;
tail.next = null;
map = new HashMap<Integer,Node>(capacity);
}

public int get(int key){
int val = -1;
if(map.containsKey(key)){
Node node = map.get(key);
val = node.value;
this.update(node);//更新链表和hashmap状态
return val;
}else{
return val;
}
}
public void set(int key, int value){
if(map.containsKey(key)){
Node node = map.get(key);
node.value = value;
this.update(node);
}else{
Node node = new Node(key, value);
node.next = null;
tail.next = node;
tail = node;
map.put(key, node);
if(size < capacity){
size++;
}else{
Node p = head.next;
int k = p.key;
head.next = p.next;
p.next = null;
p = null;
map.remove(k);
}
}

}

//当调用get和set方法时，当前节点应该需要置于最新状态，即将该节点放置到链表的尾部。采用的是单向链表，节点的删除需要从头遍历链表到当前节点的前一个节点，时间
//时间复杂度为O(n)，这里采用O(1)的时间复杂度删除节点p。
//交换节点p和p.next的值，此时删除p.next，即将该节点插入到尾部即可。但需要注意的是在hashmap中就要将p.key和p.next.key的节点交换一下，否则hashmap维护的节点
//就是错误的了。
public void update(Node p){
if(p != tail){
Node p2 = p.next;
map.put(p.key, p2);//更新hashmap中的节点
map.put(p2.key, p);//更新hashmap中的节点
int temp = p.key;
p.key = p2.key;
p2.key = temp;
temp = p.value;
p.value = p2.value;
p2.value = temp;
if(p2 != tail){
p.next = p2.next;
p2.next = null;
tail.next = p2;
tail = p2;
}
}
}

public void printList(){
Node p = head.next;
while(p != null){
System.out.print(p.key +"->" + p.value + ",");
p = p.next;
}
System.out.println();
}
}

class Node{
int key;
int value;
Node next;

public Node(){
}

public Node(int key, int value){
this.key = key;
this.value = value;
}
}