LRU用HashMap,双向链表的实现

leetcode的题解已经很完美了，这里记录下关于底下几个comments的问题：

来源：力扣（LeetCode）

这段代码很好。。

import java.util.Hashtable;
public class LRUCache {

  class DLinkedNode {
    int key;
    int value;
    DLinkedNode prev;
    DLinkedNode next;
  }

  private void addNode(DLinkedNode node) {
    /**
     * Always add the new node right after head.
     */
    node.prev = head;
    node.next = head.next;

    head.next.prev = node;
    head.next = node;
  }

  private void removeNode(DLinkedNode node){
    /**
     * Remove an existing node from the linked list.
     */
    DLinkedNode prev = node.prev;
    DLinkedNode next = node.next;

    prev.next = next;
    next.prev = prev;
  }

  private void moveToHead(DLinkedNode node){
    /**
     * Move certain node in between to the head.
     */
    removeNode(node);
    addNode(node);
  }

  private DLinkedNode popTail() {
    /**
     * Pop the current tail.
     */
    DLinkedNode res = tail.prev;
    removeNode(res);
    return res;
  }

  private Hashtable<Integer, DLinkedNode> cache =
          new Hashtable<Integer, DLinkedNode>();
  private int size;
  private int capacity;
  private DLinkedNode head, tail;

  public LRUCache(int capacity) {
    this.size = 0;
    this.capacity = capacity;

    head = new DLinkedNode();
    // head.prev = null;

    tail = new DLinkedNode();
    // tail.next = null;

    head.next = tail;
    tail.prev = head;
  }

  public int get(int key) {
    DLinkedNode node = cache.get(key);
    if (node == null) return -1;

    // move the accessed node to the head;
    moveToHead(node);

    return node.value;
  }

  public void put(int key, int value) {
    DLinkedNode node = cache.get(key);

    if(node == null) {
      DLinkedNode newNode = new DLinkedNode();
      newNode.key = key;
      newNode.value = value;

      cache.put(key, newNode);
      addNode(newNode);

      ++size;

      if(size > capacity) {
        // pop the tail
        DLinkedNode tail = popTail();
        cache.remove(tail.key);
        --size;
      }
    } else {
      // update the value.
      node.value = value;
      moveToHead(node);
    }
  }
}

/**
 * LRUCache 对象会以如下语句构造和调用:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

为什么选择双向链表，我们回到题意，LRU，在超过容量的时候，我们删除的是head->next,还是tail->prev?上面代码看的仔细的知道是tail->prev,也就是说，最近被访问的元素会被安排到head->next,这是最安全的位置了。。

有说用队列的？

-----我们来好好唠唠，要知道我们get(key)之后就找到这个结点的引用，然后要先删除该元素，再moveToHead，要知道队列删除元素的复杂读，队列是FIFO的，根本不适合删除中间结点（你自己想想怎么删除）。。另外，链表和数组是很多集合的底层实现，o(1)的时间复杂度删除结点，链表就是很好的实现，至于为什么要双向链表，因为我们在删除的时候访问tail,在add的时候，访问head,懂了吧？

这题看完可以看看LinkedHashMap的实现，思路类似，这里算是简单的实现了。