#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.

分析： HashTable + DoublyLinkedList, LRU Cache中维护两个Node， first， last， 越靠近last的表示越least recently used，每次做get， set操作的时候，当前节点是 least recently used，
需要把他移动到LRU Cache中的last， 主要就是判断当前节点是否为first或者last，还有就是判断当前LRU的first/last 是否为null，学习了Code ganker大神的解法http://blog.csdn.net/linhuanmars/article/details/21310633， 看了思路之后自己试着写了个适合自己的版本

public class LRUCache {
class Node{
Node pre;
Node next;
int val;
int key;
public Node(int key, int val){
this.val = val;
this.key = key;
}
}

private int capacity;
private int num;
private Node first;
private Node last;
private Map<Integer, Node> map;

public LRUCache(int capacity) {
this.capacity = capacity;
this.num = 0;
this.map = new HashMap<Integer, Node>();
}

public int get(int key) {
Node node = map.get(key);
if(node == null){
return -1;
}
if(node != last){
if(node == first){
first = first.next;
if(first != null){
first.pre = null;
}
}else{
node.next.pre = node.pre;
node.pre.next = node.next;
}
last.next = node;
node.pre = last;
last = node;
node.next = null;
}
return node.val;
}

public void set(int key, int value) {
Node node = map.get(key);
if(node == null){
node = new Node(key, value);
map.put(key, node);// don't forget to add new entry for new key - node pair.
if(first == null){
first = node;
last = node;
num++;
}else{
if(num == capacity){
map.remove(first.key);// don't forget to delete map key
first = first.next;
if(first != null){
first.pre = null;
}
}else{
num++;
}
last.next = node;
node.pre = last;
last = node;
}
}else{
node.val = value;
if(node != last){
if(node == first){
first = first.next;
}else{
node.pre.next = node.next;
node.next.pre = node.pre;
}
last.next = node;
node.pre = last;
last = node;
}
}
}
}