题目：LRU 缓存机制 设计和实现一个 LRU（最近最少使用）缓存数据结构，使它应该支持一下操作：get 和 put。 get(key) - 如果 key 存在于缓存中，则获取 key 的 value（总是正数），否则返回 -1。 put(key,value) - 如果 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
思路解析
这道题是让我们实现一个 LRU 缓存器，LRU是Least Recently Used的简写，就是最近最少使用的意思。
这个缓存器主要有两个成员函数，get和put。
其中 get 函数是通过输入 key 来获得 value，如果成功获得后，这对 (key, value) 升至缓存器中最常用的位置（顶部），如果 key 不存在，则返回 -1 。
而 put 函数是插入一对新的 (key, value)，如果原缓存器中有该 key，则需要先删除掉原有的，将新的插入到缓存器的顶部。如果不存在，则直接插入到顶部。
若加入新的值后缓存器超过了容量，则需要删掉一个最不常用的值，也就是底部的值。
具体实现时我们需要三个私有变量，cap , l 和 m，其中 cap 是缓存器的容量大小，l 是保存缓存器内容的列表，m 是 HashMap，保存关键值 key 和缓存器各项的迭代器之间映射，方便我们以 O(1) 的时间内找到目标项。
然后我们再来看 get 和 put 如何实现。
其中，get 相对简单些，我们在 m 中查找给定的key，若不存在直接返回 -1；如果存在则将此项移到顶部。
对于 put ，我们也是现在 m 中查找给定的 key，如果存在就删掉原有项，并在顶部插入新来项，然后判断是否溢出，若溢出则删掉底部项(最不常用项)。
动画演示
动画录制少录了几秒，见谅：
参考代码
python版本的：
class LRUCache(object):
def __init__(self, capacity):
"""
:type capacity: int
"""
self.cache = {}
self.keys = []
self.capacity = capacity
def visit_key(self, key):
if key in self.keys:
self.keys.remove(key)
self.keys.append(key)
def elim_key(self):
key = self.keys[0]
self.keys = self.keys[1:]
del self.cache[key]
def get(self, key):
"""
:type key: int
:rtype: int
"""
if not key in self.cache:
return -1
self.visit_key(key)
return self.cache[key]
def put(self, key, value):
"""
:type key: int
:type value: int
:rtype: void
"""
if not key in self.cache:
if len(self.keys) == self.capacity:
self.elim_key()
self.cache[key] = value
self.visit_key(key)
def main():
s =
[["put","put","get","put","get","put","get","get","get"],[[1,1],[2,2],[1],[3,3],[2],[
4,4],[1],[3],[4]]]
obj = LRUCache(2)
l=[]
for i,c in enumerate(s[0]):
if(c == "get"):
l.append(obj.get(s[1][i][0]))
else:
obj.put(s[1][i][0], s[1][i][1])
print(l)
if __name__ == "__main__":
main()
c++版本的：
class LRUCache{
public:
LRUCache(int capacity) {
cap = capacity;
}
int get(int key) {
auto it = m.find(key);
if (it == m.end()) return -1;
l.splice(l.begin(), l, it->second);
return it->second->second;
}
void set(int key, int value) {
auto it = m.find(key);
if (it != m.end()) l.erase(it->second);
l.push_front(make_pair(key, value));
m[key] = l.begin();
if (m.size() > cap) {
int k = l.rbegin()->first;
l.pop_back();
m.erase(k);
}
}
private:
int cap;
list<pair<int, int>> l;
unordered_map<int, list<pair<int, int>>::iterator> m;
};
Java代码：
package question;
import java.util.*;
/**
* 哈希表加双向链表。
*
* 每次新增节点时，往链表头部放入。需要删除时，删除链表尾节点。
*
* get()和put()的时间复杂度均是O(1)。空间复杂度是O(n)，其中n为缓存的键数。
*
* 执行用时：141ms，击败79.91%。消耗内存：55.7MB，击败96.89%。
*/
class LRUCache1 {
private class Node {
private int key;
private int value;
private Node pre;
private Node next;
public Node() {
}
public Node(int key, int value) {
this.key = key;
this.value = value;
}
}
private Node dummyHead = new Node();
private Node dummyTail = new Node();
private int capacity;
private int size;
private HashMap<Integer, Node> hashMap = new HashMap<>();
//将节点添加到虚拟头节点之后
private void add(Node node) {
Node originHead = dummyHead.next;
dummyHead.next = node;
node.pre = dummyHead;
node.next = originHead;
originHead.pre = node;
}
//删除某个节点
private void del(Node node) {
Node preNode = node.pre;
Node nextNode = node.next;
preNode.next = nextNode;
nextNode.pre = preNode;
node.pre = null;
node.next = null;
}
public LRUCache1(int capacity) {
dummyHead.next = dummyTail;
dummyTail.pre = dummyHead;
this.capacity = capacity;
size = 0;
}
public int get(int key) {
Node node = hashMap.get(key);
if (null == node) {
return -1;
}
del(node);
add(node);
return node.value;
}
public void put(int key, int value) {
Node node = hashMap.get(key);
if (null != node) {
node.value = value;
del(node);
add(node);
} else {
if (size < capacity) {
size++;
} else {
//删除链表尾节点
Node delNode = dummyTail.pre;
hashMap.remove(delNode.key);
del(delNode);
}
Node newNode = new Node(key, value);
add(newNode);
hashMap.put(key, newNode);
}
}
}
或
package question;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 自定义一个雷LRULinedHashMap继承自LinkedHashMap，并重写其removeEldestEntry方法。
*
* get()和put()的时间复杂度均是O(1)。空间复杂度是O(n)，其中n为缓存的键数。
*
* 执行用时：144ms，击败74.73%。消耗内存：62.3MB，击败67.95%。
*/
public class LRUCache2 {
private int capacity;
private LRULinkedHashMap<Integer, Integer> lruLinkedHashMap = new LRULinkedHashMap<>();
private class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {
@Override
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
if (size() > capacity) {
return true;
} else {
return false;
}
}
}
public LRUCache2(int capacity) {
this.capacity = capacity;
}
public int get(int key) {
Integer value = lruLinkedHashMap.get(key);
if (null == value) {
return -1;
}
lruLinkedHashMap.remove(key);
lruLinkedHashMap.put(key, value);
return value;
}
public void put(int key, int value) {
if (lruLinkedHashMap.containsKey(key)) {
lruLinkedHashMap.remove(key);
}
lruLinkedHashMap.put(key, value);
}
}