LeetCode-146：LRU缓存机制

题目描述：

 

 解题分析：

LRU是Least Recently Used，因此在插入元素时候，需要插到最前面；当达到capacity时候，需要把最后一个（即距离上次使用时间最长的那个元素）移除。因此LRU需要以下几个操作：

1、能够添加元素，并且始终将新添加的元素移到缓存最前面；

2、 在添加数据时候，如果缓存满了，需要将最后面的元素移除；

3、查询时候，如果查询到缓存中的数据，返回数据值并将该数据移动到缓存的前面，如果没有查到数据，返回-1；

实现方法：双向链表+哈希表

双向链表作用：一方面通过链表，维护节点之间的顺序，另一方面，双向链表通过伪节点head和tail，可以很方便的将最新的元素插入缓存最前面，或者将最后一个元素移除。

哈希表作用：可以在常数时间内get和put元素。

 

具体代码：（在官方的基础上改的）

import java.util.Hashtable; // Hashtable相对HashMap来说，是线程安全的
public class LRUCache {

  class DLinkedNode { //构建双向链表
    int key;
    int value;
    DLinkedNode prev;
    DLinkedNode next;
  }

  private void addNode(DLinkedNode node) {  // 始终将添加的元素放在伪节点head的后面
    node.prev = head;
    node.next = head.next;
    head.next.prev = node;
    head.next = node;
  }

  private void removeNode(DLinkedNode node){  // 移除节点
    DLinkedNode prev = node.prev;
    DLinkedNode next = node.next;
    prev.next = next;
    next.prev = prev;
  }

  private void moveToHead(DLinkedNode node){  // 将节点移动到缓存的前面
    removeNode(node);
    addNode(node);
  }

  private DLinkedNode popTail() {  // 移除缓存最后面的节点
    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) {  // 初始化缓存，构建以伪节点head和tail为开头和结尾的双向链表
    this.size = 0;
    this.capacity = capacity;
    head = new DLinkedNode();
    tail = new DLinkedNode();
    head.next = tail;
    tail.prev = head;
  }

  public int get(int key) {
    DLinkedNode node = cache.get(key);
    if (node == null) return -1;
    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) {
        DLinkedNode tail = popTail();
        cache.remove(tail.key);
        --size;
      }
    } else {
      node.value = value;
      moveToHead(node);
    }
  }
}