146.LRUCache

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

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
put(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.

Follow up:
Could you do both operations in O(1) time complexity?

 

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

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

class LRUCache {
  int capacity;
  Map<Integer, Node> map = new HashMap();//key是Integer，value是Node
  Node head = null;
  Node end = null;

  public LRUCache(int capacity) {
    this.capacity = capacity;
  }

  public int get(int key) {
    if(map.containsKey(key)) {
      Node temp = map.get(key);
      remove(temp);
      setHead(temp);
      return temp.value;
    }
    return -1;
  }

  public void put(int key, int value) {
    if(map.containsKey(key)) {
      Node old = map.get(key);
      old.value = value;
      remove(old);
      setHead(old);
    } else {
      Node created = new Node(key,value);
      if(map.size() >= capacity) {
        map.remove(end.key);
        remove(end);
      }
      setHead(created);
      map.put(key,created);
    }
  }

  public void remove(Node n) {
    if(n.pre != null) {
      n.pre.next = n.next;
    } else {
      head = n.next;
    }

    if(n.next != null) {
      n.next.pre = n.pre;
    } else {
      end = n.pre;
    }
  }

  public void setHead(Node n) {
    n.next = head;
    n.pre = null;
    if(head != null)
      head.pre = n;
    head = n;
    if(end == null)
      end = head;
  }
}