简介
LRU (Least Recently Used) 缓存，即在缓存容量达到上限的条件下，删除最久未使用过的数据，腾出空间存储新的数据。
LFU (Least Frequently Used) 缓存，即在缓存容量达到上限的条件下，删除使用频率最少的数据，当使用频率相同时，删除最久未使用的数据。
这两种缓存算法在实践中用得非常普遍，例如MySQL的内存数据页淘汰算法，Redis的淘汰策略等。
例题
以上题目均来自leetcode.
详细
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
分析
这道题有很多实现方式，我们直接看进阶要求，要求 put 和 get 操作要在 O(1) 时间复杂度下完成。
我们可以用一个双向链表存储数据，这样方便移除最久未使用的数据，同时，用一个字典存储 key 和链表中节点的映射关系，方便直接从 key 获取节点，从而进行删除节点等操作。
同时，每次put或者get数据，将数据移动到链表尾部。
代码
lass LRUCache {
class Node {
private int key;
private int value;
private Node next;
private Node pre;
public Node() {
}
public Node(int key, int value) {
this.key = key;
this.value = value;
}
}
private int capacity;
private int count;
private Map<Integer, Node> map;
private Node head;
private Node tail;
public LRUCache(int capacity) {
this.capacity = capacity;
count = 0;
map = new HashMap<>();
head = new Node();
tail = new Node();
head.next = tail;
tail.pre = head;
}
// 移动节点到链表尾部
private void moveToTail(Node node) {
// 取出
node.pre.next = node.next;
node.next.pre = node.pre;
// 插入尾部
addNode(node);
}
// 在尾部添加一个节点
private void addNode(Node node) {
Node pre = tail.pre;
node.pre = pre;
pre.next = node;
node.next = tail;
tail.pre = node;
}
// 删除第一个节点
private void deleteFirst() {
Node node = head.next;
node.pre.next = node.next;
node.next.pre = node.pre;
map.remove(node.key);
}
public int get(int key) {
if (!map.containsKey(key)) {
return -1;
}
Node node = map.get(key);
moveToTail(node);
return node.value;
}
public void put(int key, int value) {
if (map.containsKey(key)) {
Node node = map.get(key);
node.value = value;
moveToTail(node);
} else {
Node node = new Node(key, value);
if (count < capacity) {
count++;
map.put(key, node);
addNode(node);
} else {
deleteFirst();
map.put(key, node);
addNode(node);
}
}
}
}
说明：在双向链表中，创建虚拟的头结点和尾节点，这样保证链表始终不为空，并且添加进入的数据不会是头结点和尾节点，这样可以省去很多空值的判断。
460. LFU缓存
简介
请你为 最不经常使用（LFU）缓存算法设计并实现数据结构。它应该支持以下操作：get 和 put。
get(key) - 如果键存在于缓存中，则获取键的值（总是正数），否则返回 -1。
put(key, value) - 如果键已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量时，则应该在插入新项之前，使最不经常使用的项无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除最久未使用的键。
「项的使用次数」就是自插入该项以来对其调用 get 和 put 函数的次数之和。使用次数会在对应项被移除后置为 0 。
进阶：
你是否可以在 O(1) 时间复杂度内执行两项操作？
示例：
LFUCache cache = new LFUCache( 2 /* capacity (缓存容量) */ );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1); // 返回 1
cache.put(3, 3); // 去除 key 2
cache.get(2); // 返回 -1 (未找到key 2)
cache.get(3); // 返回 3
cache.put(4, 4); // 去除 key 1
cache.get(1); // 返回 -1 (未找到 key 1)
cache.get(3); // 返回 3
cache.get(4); // 返回 4
分析
LFU 和 LRU 的区别在于需要保存每条数据的使用频率。
我们为每个频率保存一个双向链表，同时建立一个频率和相应链表的映射freqMap。
建立另一个keyMap，记录存储数据的 key和对应节点的映射。
代码
class LFUCache {
class Node {
private int key;
private int value;
private int freq;
private Node next;
private Node pre;
public Node() {
}
public Node(int key, int value) {
this.key = key;
this.value = value;
this.freq = 1;
}
}
// 不同频率对应的链表头节点和尾节点
private Map<Integer, Node[]> freqMap;
// 键对应的节点
private Map<Integer, Node> keyMap;
private int capacity;
private int count;
// 记录当前的最小频率
private int minFreq;
public LFUCache(int capacity) {
this.capacity = capacity;
count = 0;
freqMap = new HashMap<>();
keyMap = new HashMap<>();
minFreq = -1;
}
// 初始化一个双向链表的首位节点
private Node[] intiDLinked() {
Node head = new Node();
Node tail = new Node();
head.next = tail;
tail.pre = head;
return new Node[]{head, tail};
}
// 删除一个指定的节点，并修改minFreq
private void deleteNode(Node node) {
node.next.pre = node.pre;
node.pre.next = node.next;
// check minFreq
int freq = node.freq;
Node[] headAndTail = freqMap.get(node.freq);
if (minFreq == freq && headAndTail[0].next == headAndTail[1]) {
minFreq++;
}
}
// 插入一个节点，根据节点的频率插入到相应的链表中
private void insertInto(Node node) {
int freq = node.freq;
Node tail;
if (!freqMap.containsKey(freq)) {
Node[] headAndTail = intiDLinked();
tail = headAndTail[1];
freqMap.put(freq, headAndTail);
} else {
tail = freqMap.get(freq)[1];
}
Node pre = tail.pre;
pre.next = node;
node.pre = pre;
node.next = tail;
tail.pre = node;
}
// 将一个节点频率加一后插入新的链表
private void addFreq(Node node) {
// get from origin freq
deleteNode(node);
node.freq++;
// insert into new freq
insertInto(node);
}
// 淘汰最小频率
private void deleteMinFreq() {
Node[] headAndTail = freqMap.get(minFreq);
Node head = headAndTail[0], tail = headAndTail[1];
Node node = head.next;
node.next.pre = node.pre;
node.pre.next = node.next;
keyMap.remove(node.key);
if (head.next == tail) {
minFreq = 1; // 此时肯定是有新的数据插入导致需要删除最小频率的数，所以minFreq变为1
}
}
public int get(int key) {
if (!keyMap.containsKey(key)) {
return -1;
}
Node node = keyMap.get(key);
addFreq(node);
return node.value;
}
public void put(int key, int value) {
if (keyMap.containsKey(key)) {
Node node = keyMap.get(key);
node.value = value;
addFreq(node);
} else {
Node node = new Node(key, value);
if (capacity == 0) {
return;
} else if (count < capacity) {
count++;
} else {
// 最小频率
deleteMinFreq();
}
node.freq = 1;
minFreq = 1;
insertInto(node);
keyMap.put(key, node);
}
}
}
注意：维护一个minFreq，记录当前的最小频率，这样在淘汰元素的时候可以直接去对象的链表删除节点，避免了循环查找最小频率。
385
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
