前言
什么是LRU算法，就是一種緩存淘汰策略。
計算機的緩存容量有限，如果緩存滿了就要刪除一些內容，給新內容騰位置。但問題是，刪除哪些內容呢？我們肯定希望刪掉哪些沒什么用的緩存，而把有用的數據繼續留在緩存里，方便之后繼續使用。那么，什么樣的數據，我們判定為「有用的」的數據呢？
LRU 緩存淘汰算法就是一種常用策略。LRU 的全稱是 Least Recently Used，也就是說我們認為最近使用過的數據應該是是「有用的」，很久都沒用過的數據應該是無用的，內存滿了就優先刪那些很久沒用過的數據。
LRU緩存機制對應Leetcode 146。
運用你所掌握的數據結構，設計和實現一個 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
get操作： 有找到 返回值，並且將它置為"最近使用",沒有找到 返回 -1
put操作：存在值 更新並且將它置為"最近使用"，不存在值 容量夠，增加，放在"最近使用"。容量不夠 刪除使用頻次最少的 增加放在"最近使用"
使用隊列可以將剛使用的放在隊列頭，這樣隊列尾就是最近沒使用的，淘汰的話先淘汰隊列尾的,最近使用的放在隊列頭。單純的隊列是不行的，需要雙向鏈表，比如我們想把中間的值提出來，想將這個值的前繼節點和后繼節點進行相連。
但是get操作無法O(1)get到操作，隊列中只能遍歷查找值。如果更快get到值可以使用HashMap的數據結構。
將兩種數據結構相結合成哈希鏈表，如下圖所示
代碼實現
public class LRUCache {
private Map<Integer, LRUNode> map;
private DoubleList doubleList;
// 當前存儲的數量
int capacity;
public LRUCache(int capacity) {
this.capacity = capacity;
map = new HashMap();
doubleList = new DoubleList();
}
// 有找到 返回值，並且將它置為最新使用
// 沒有找到 返回 -1
public int get(int key) {
LRUNode lruNode = map.get(key);
if (lruNode == null) {
return -1;
} else {
put(key, lruNode.val);
return lruNode.val;
}
}
// 存在值 更新並且將它置為最新使用
// 不存在值 容量夠，增加
// 容量不夠 刪除使用頻次最少的 增加放在最近使用
public void put(int key, int value) {
LRUNode lruNode = map.get(key);
LRUNode toAddNode = new LRUNode(key, value);
if (lruNode != null) {
doubleList.delNode(lruNode);
doubleList.addFirst(toAddNode);
// 更新map 中存儲的value
map.put(key, toAddNode);
} else {
if (doubleList.getListSize() == capacity) {
LRUNode last = doubleList.removeLast();
// LRUNode 中記錄key 便於此處從map中刪除指定key
map.remove(last.key);
}
doubleList.addFirst(toAddNode);
map.put(key, toAddNode);
}
}
class LRUNode {
int key;
int val;
LRUNode pre, next;
public LRUNode(int key, int val) {
this.key = key;
this.val = val;
}
}
class DoubleList {
/**
* 頭尾虛節點 便於插入 和淘汰
*/
private LRUNode head, tail;
private int size;
public DoubleList() {
head = new LRUNode(0, 0);
tail = new LRUNode(0, 0);
head.next = tail;
tail.pre = head;
size = 0;
}
/**
* 往雙向鏈表頭部插入
*
* @param node
*/
public void addFirst(LRUNode node) {
node.next = head.next;
node.pre = head;
head.next.pre = node;
head.next = node;
size++;
}
/**
* 刪除鏈表中x 節點 x一定存在
*
* @param x
*/
public void delNode(LRUNode x) {
x.pre.next = x.next;
x.next.pre = x.pre;
size--;
}
/**
* 刪除結尾節點 返回該節點
*
* @return
*/
public LRUNode removeLast() {
if (tail.pre == head) {
return null;
}
LRUNode removeNode = tail.pre;
delNode(removeNode);
return removeNode;
}
/**
* 返回鏈表長度
*
* @return
*/
public int getListSize() {
return size;
}
}
}
很容易犯錯的一點是：處理鏈表節點的同時不要忘了更新哈希表中對節點的映射。