今日头条高频面试题LRU
题目
运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持如下操做： 获取数据 get 和 写入数据 put 。web
获取数据 get(key) - 若是密钥 (key) 存在于缓存中，则获取密钥的值（老是正数），不然返回 -1。
写入数据 put(key, value) - 若是密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据以前删除最近最少使用的数据值，从而为新的数据值留出空间。缓存
进阶:数据结构
你是否能够在 O(1) 时间复杂度内完成这两种操做？svg
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
题解
这道题在今日头条、快手或者硅谷的公司中是比较常见的，代码要写的还蛮多的，难度也是hard级别。post
最重要的是LRU 这个策略怎么去实现,
很容易想到用一个链表去实现最近使用的放在链表的最前面。
好比get一个元素,至关于被使用过了，这个时候它须要放到最前面，再返回值,
set同理。
那如何把一个链表的中间元素，快速的放到链表的开头呢？
很天然的咱们想到了双端链表。this
基于 HashMap 和 双向链表实现 LRU 的
总体的设计思路是，可使用 HashMap 存储 key，这样能够作到 save 和 get key的时间都是 O(1)，而 HashMap 的 Value 指向双向链表实现的 LRU 的 Node 节点，如图所示。
设计
LRU 存储是基于双向链表实现的，下面的图演示了它的原理。其中 head 表明双向链表的表头，tail 表明尾部。首先预先设置 LRU 的容量，若是存储满了，能够经过 O(1) 的时间淘汰掉双向链表的尾部，每次新增和访问数据，均可以经过 O(1)的效率把新的节点增长到对头，或者把已经存在的节点移动到队头。code
下面展现了，预设大小是 3 的，LRU存储的在存储和访问过程当中的变化。为了简化图复杂度，图中没有展现 HashMap部分的变化，仅仅演示了上图 LRU 双向链表的变化。咱们对这个LRU缓存的操做序列以下：xml
save("key1", 7)
save("key2", 0)
save("key3", 1)
save("key4", 2)
get("key2")
save("key5", 3)
get("key2")
save("key6", 4)
相应的 LRU 双向链表部分变化以下：
总结一下核心操做的步骤:
save(key, value)，首先在 HashMap 找到 Key 对应的节点，若是节点存在，更新节点的值，并把这个节点移动队头。若是不存在，须要构造新的节点，而且尝试把节点塞到队头，若是LRU空间不足，则经过 tail 淘汰掉队尾的节点，同时在 HashMap 中移除 Key。
get(key)，经过 HashMap 找到 LRU 链表节点，由于根据LRU 原理，这个节点是最新访问的，因此要把节点插入到队头，而后返回缓存的值。
private static class DLinkedNode {
int key;
int value;
DLinkedNode pre;
DLinkedNode post;
}
/**
* 老是在头节点中插入新节点.
*/
private void addNode(DLinkedNode node) {
node.pre = head;
node.post = head.post;
head.post.pre = node;
head.post = node;
}
/**
* 摘除一个节点.
*/
private void removeNode(DLinkedNode node) {
DLinkedNode pre = node.pre;
DLinkedNode post = node.post;
pre.post = post;
post.pre = pre;
}
/**
* 摘除一个节点,而且将它移动到开头
*/
private void moveToHead(DLinkedNode node) {
this.removeNode(node);
this.addNode(node);
}
/**
* 弹出最尾巴节点
*/
private DLinkedNode popTail() {
DLinkedNode res = tail.pre;
this.removeNode(res);
return res;
}
private HashMap<Integer, DLinkedNode>
cache = new HashMap<Integer, DLinkedNode>();
private int count;
private int capacity;
private DLinkedNode head, tail;
public LRUCache(int capacity) {
this.count = 0;
this.capacity = capacity;
head = new DLinkedNode();
head.pre = null;
tail = new DLinkedNode();
tail.post = null;
head.post = tail;
tail.pre = head;
}
public int get(int key) {
DLinkedNode node = cache.get(key);
if (node == null) {
return -1; // cache里面没有
}
// cache 命中,挪到开头
this.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;
this.cache.put(key, newNode);
this.addNode(newNode);
++count;
if (count > capacity) {
// 最后一个节点弹出
DLinkedNode tail = this.popTail();
this.cache.remove(tail.key);
count--;
}
} else {
// cache命中,更新cache.
node.value = value;
this.moveToHead(node);
}
}