Leetcode NO.146 lru-cache LRU Cache 最近最少使用實現
1.問題描述
運用你所掌握的資料結構，設計和實現一個 LRU (最近最少使用) 快取機制 。
實現 LRUCache 類：
LRUCache(int capacity) 以正整數作為容量 capacity 初始化 LRU 快取
int get(int key) 如果關鍵字 key 存在於快取中，則返回關鍵字的值，否則返回 -1 。
void put(int key, int value) 如果關鍵字已經存在，則變更其資料值；如果關鍵字不存在，則插入該組「關鍵字-值」。當快取容量達到上限時，它應該在寫入新資料之前刪除最久未使用的資料值，從而為新的資料值留出空間。
注意：
你只能使用佇列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 這些操作。
你所使用的語言也許不支援佇列。 你可以使用 list （列表）或者 deque（雙端佇列）來模擬一個佇列 , 只要是標準的佇列操作即可。
2.測試用例
示例 1
輸入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
輸出
[null, null, null, 1, null, -1, null, -1, 3, 4]
解釋
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 快取是 {1=1}
lRUCache.put(2, 2); // 快取是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 該操作會使得關鍵字 2 作廢，快取是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 該操作會使得關鍵字 1 作廢，快取是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4
3.提示
-
1 <= capacity <= 3000
-
0 <= key <= 10000
-
0 <= value <= 105
-
最多呼叫 2 * 105 次 get 和 put
4.程式碼
1.繼承LinkedHashMap實現
code
public class LRU_Cache_With_LinkedHashMap extends LinkedHashMap<Integer, Integer> {
private int capacity;
public LRU_Cache_With_LinkedHashMap(int initialCapacity) {
/**
* initialCapacity 容量
* loadFactor 擴容因子
* accessOrder false 不刪除，
*/
super(initialCapacity, 0.75f, true);
this.capacity = initialCapacity;
}
@Override
public Integer get(Object key) {
return super.get(key) == null ? -1 : super.get(key);
}
@Override
public Integer put(Integer key, Integer value) {
return super.put(key, value);
}
@Override
protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
// return true 的話，如果map容量已滿，允許新的插入，並且移除老的資料
//這裡是實現，容量滿了以後，最老的資料刪除的操作
return size() > capacity;
}
}
複雜度
1.時間 O(1)
2.空間 O(capacity)
2.HashMap && DoubleLinklist
code
public class LRUCache {
private int capacity;
private int size;
private DoubleListNode startSentinel;
private DoubleListNode endSentinel;
private HashMap<Integer, DoubleListNode> hashMap;
public LRUCache(int capacity) {
this.capacity = capacity;
this.size = 0;
hashMap = new HashMap<>(capacity);
startSentinel = new DoubleListNode();
endSentinel = new DoubleListNode();
startSentinel.next = endSentinel;
endSentinel.pre = startSentinel;
}
class DoubleListNode {
private Integer key;
private Integer val;
private DoubleListNode pre;
private DoubleListNode next;
public DoubleListNode() {
}
public DoubleListNode(Integer key, Integer val) {
this.key = key;
this.val = val;
}
@Override
public String toString() {
return "val=" + val;
}
}
@Override
public String toString() {
return "LRUCache{" +
"hashMap=" + hashMap +
'}';
}
public Integer get(Integer key) {
DoubleListNode node = hashMap.get(key);
//獲取不到返回-1
if (node == null) {
return -1;
}
//移動資料到連結串列結尾
moveToTail(node);
return node.val;
}
public void put(Integer key, Integer value) {
DoubleListNode node = hashMap.get(key);
if (node == null) {
//判斷當前size 和 capacity 的大小
if (size < capacity) {
//size ++
size++;
//新增節點
node = new DoubleListNode(key, value);
//移動新節點到連結串列末尾
addToTail(node);
hashMap.put(key, node);
} else {
//刪除頭結點
DoubleListNode rmNode = removeNode(startSentinel.next);
hashMap.remove(rmNode.key);
//移動新節點到連結串列尾部
DoubleListNode newNode = new DoubleListNode(key, value);
addToTail(newNode);
//新增結點到hashmap
hashMap.put(key,newNode);
}
} else {
//更新值
node.val = value;
//放到尾部
moveToTail(node);
}
}
/**
* 移動節點到連結串列尾部
*
* @param node
*/
private void moveToTail(DoubleListNode node) {
removeNode(node);
addToTail(node);
}
/**
* 新增結點到雙向連結串列尾部
*
* @param node node
*/
private void addToTail(DoubleListNode node) {
node.next = endSentinel;
node.pre = endSentinel.pre;
endSentinel.pre.next = node;
endSentinel.pre = node;
}
/**
* 移除節點
* @param node node
* @return re
*/
private DoubleListNode removeNode(DoubleListNode node) {
node.pre.next = node.next;
node.next.pre = node.pre;
return node;
}
}
複雜度
1.時間 O(1)
2.空間 O(capacity)