每日一题（2020-05-25）146. LRU缓存机制

[146. LRU缓存机制]

难度 中等

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥已经存在，则变更其数据值；如果密钥不存在，则插入该组「密钥/数据值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

进阶:

你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例:

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 该操作会使得密钥 2 作废
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 该操作会使得密钥 1 作废
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lru-cache

解法：hashMap + 双向链表（首尾指针）

使用哈希表和双向链表维护所有在缓存中的键值对。

双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。

哈希表存储对应的键，及其在双向链表中值， 这样方便在双链表中删除对应的值。

class LRUCache {
	int capacity;	//缓存总容量
	int size;	//已存储容量
	private Map<Integer, Node> cache = new HashMap<Integer, Node>();
	private DLinked dLinked;	//双向链表
	
	public LRUCache(int capacity) {
		this.capacity = capacity;
		this.size = 0;
		this.dLinked = new DLinked();
    }
    
    public int get(int key) {
    	Node node = cache.get(key);
    	//密钥 (key) 不存在于缓存中， 返回 -1
         if (node == null) {
             return -1;
         }
         // 如果 key 存在，将其移到链表头部
         dLinked.moveToHead(node);
         return node.value;   	
    }
    
    public void put(int key, int value) {
    	Node node = cache.get(key);
    	if(node == null) {
    		Node newNode = new Node(key, value);
    		//添加到哈希表中
    		cache.put(key, newNode);
    		dLinked.addToHead(newNode);
    		size++;
    		//判断是否超出容量
    		if(size > capacity) {
    			Node tail = dLinked.removeTail();
    			cache.remove(tail.key);
    			size--;
    		}
    		
    	}else {
    		// 如果 key 存在，再修改 value，并移到头部
            node.value = value;
            dLinked.moveToHead(node);
    	}
    }
}

//双向链表（首尾指针）
class DLinked {
	private Node head;	//头结点
	private Node tail;	//尾结点
	public DLinked() {
		//使用伪头部和伪尾部节点
		this.head = new Node();
		this.tail = new Node();
		head.next = tail;
        tail.pre = head;
	}	
	
	public Node removeTail() {
		Node res = tail.pre;
		removeNode(res);
		return res;
	}

	public void addToHead(Node node) {
		node.pre = head;
        node.next = head.next;
        head.next.pre = node;
        head.next = node;
	}

	//将链表的对应节点添加到链表头部
	public void moveToHead(Node node) {
		//移除对应节点
		removeNode(node);
		//添加到头部
		addToHead(node);
	}
	
	private void removeNode(Node node) {
		node.pre.next = node.next;
        node.next.pre = node.pre;	
	}
}

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