1.LRU简介
LRU（Least Recently Used）是一种常见的页面置换算法，在计算中，所有的文件操作都要放在内存中进行，然而计算机内存大小是固定的，所以我们不可能把所有的文件都加载到内存，因此我们需要制定一种策略对加入到内存中的文件进项选择。
LRU的设计原理就是，当数据在最近一段时间经常被访问，那么它在以后也会经常被访问。这就意味着，如果经常访问的数据，我们需要然其能够快速命中，而不常访问的数据，我们在容量超出限制内，要将其淘汰。
常见的页面置换算法有如下几种：
- LRU 最近最久未使用
- FIFO 先进先出置换算法 类似队列
- OPT 最佳置换算法 （理想中存在的）
- NRU Clock置换算法
- LFU 最少使用置换算法
- PBA 页面缓冲算法
2.题目描述
请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。
实现 LRUCache 类：
LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。
函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。
3.分析
数组 查询复杂度O(1)，但是增删需要移动后面的全部元素，复杂度O(n)
链表 增删复杂度O(1)，但是查询需要从头遍历链表，复杂度O(n)
综上，考虑使用 HashMap + 链表，我们还需要根据删除链表中的任一节点，将他移动到最前面，所以使用双向链表实现。
- 双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。
- 哈希表即为普通的哈希映射（HashMap），通过缓存数据的键映射到其在双向链表中的位置。
这样，在get和put的时候，我们通过HashMap找到key对应的节点，将节点移动到链表的头部，从而在 O(1) 的时间内完成get和put 操作。具体如下
- 对于
get(key)操作- 如果key存在，先通过map找到对应节点，将当前节点移动到列表的头部，然后返回value
- 如果key不存在，就返回-1
- 对于
put(key, value)操作- 如果key存在，先通过map找到对应节点，然后将节点移动到列表的头部，修改节点的value
- 如果key不存在，使用key和value创建一个新的节点和map，将节点移动到列表的头部；如果map集合的大小超出容量，删除双向链表的最后一个节点，并删除map中的对应值。
4.代码实现
Java
/**
* LRU 最近最少使用
*
* 1.获取数据 get(key)
* 如果关键字 (key) 存在于缓存中，则获取关键字的值（总是正数），否则返回 -1。
*
* 2.写入数据 put(key, value)
* 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字/值」。
* 当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
*
* 你是否可以在 O(1) 时间复杂度内完成这两种操作？
*/
class LRUCache {
class Node<K, V> {
private K key;
private V value;
private Node<K, V> prev;
private Node<K, V> next;
public Node(K key, V value) {
this.key = key;
this.value = value;
this.prev = null;
this.next = null;
}
}
int capacity;
Map<Integer, Node<Integer, Integer>> map;
Node<Integer, Integer> head;
public LRUCache(int capacity) {
this.capacity = capacity;
map = new HashMap<>(capacity);
head = new Node<Integer, Integer>(0, 0);
head.prev = head;
head.next = head;
}
public int get(int key) {
// 如果不存在
if(!map.containsKey(key)) {
return -1;
}
// 找到对应节点，并将其移动到最前面
Node<Integer, Integer> node = map.get(key);
node.prev.next = node.next;
node.next.prev = node.prev;
insert(node);
return node.value;
}
public void put(int key, int value) {
/**
* 如果key已存在
* 1.删除原来的node
* 2.变更node的value
* 3.将变更后的node放到最前面
*/
if(map.containsKey(key)) {
Node<Integer, Integer> node = map.get(key);
// 删除node
node.prev.next = node.next;
node.next.prev = node.prev;
// 变更value并插入最前面
node.value = value;
insert(node);
return;
}
/**
* 如果key不存在
* 1.将数据插入node放到最前面
* 2.如果超出容量，就删除最久未使用的node（最后的node）
*/
Node<Integer, Integer> node = new Node(key, value);
map.put(key, node);
insert(node);
if(map.size() > capacity) {
// 删除key
int x = head.prev.key;
map.remove(x);
// 删除节点
remove();
}
}
// 头插法
public void insert(Node node) {
Node first = head.next;
node.next = first;
first.prev = node;
head.next = node;
node.prev = head;
}
// 删除最后一个节点
public void remove() {
Node last = head.prev;
last.prev.next = last.next;
last.next.prev = last.prev;
}
}
