|
|
package 第03期.mca_05;
|
|
|
|
|
|
import java.util.HashMap;
|
|
|
|
|
|
// 测试链接 : https://leetcode.cn/problems/lru-cache/
|
|
|
public class Code05_LRUCache {
|
|
|
|
|
|
// 提交以下这个类
|
|
|
public class LRUCache {
|
|
|
|
|
|
public static class Node {
|
|
|
public int key;
|
|
|
public int val;
|
|
|
public Node last;
|
|
|
public Node next;
|
|
|
|
|
|
public Node(int k, int v) {
|
|
|
key = k;
|
|
|
val = v;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public static class DoubleLinkedList {
|
|
|
private Node head;
|
|
|
private Node tail;
|
|
|
|
|
|
public DoubleLinkedList() {
|
|
|
head = null;
|
|
|
tail = null;
|
|
|
}
|
|
|
|
|
|
public void addNode(Node newNode) {
|
|
|
if (newNode == null) {
|
|
|
return;
|
|
|
}
|
|
|
if (head == null) {
|
|
|
head = newNode;
|
|
|
tail = newNode;
|
|
|
} else {
|
|
|
tail.next = newNode;
|
|
|
newNode.last = tail;
|
|
|
tail = newNode;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void moveNodeToTail(Node x) {
|
|
|
if (tail == x) {
|
|
|
return;
|
|
|
}
|
|
|
if (head == x) { // x在头部
|
|
|
head = x.next;
|
|
|
head.last = null;
|
|
|
} else {
|
|
|
x.last.next = x.next;
|
|
|
x.next.last = x.last;
|
|
|
}
|
|
|
x.last = tail;
|
|
|
x.next = null;
|
|
|
tail.next = x;
|
|
|
tail = x;
|
|
|
}
|
|
|
|
|
|
public Node removeHead() {
|
|
|
if (head == null) {
|
|
|
return null;
|
|
|
}
|
|
|
Node ans = head;
|
|
|
if (head == tail) {
|
|
|
head = null;
|
|
|
tail = null;
|
|
|
} else {
|
|
|
head = ans.next;
|
|
|
ans.next = null;
|
|
|
head.last = null;
|
|
|
}
|
|
|
return ans;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
// A -> Node
|
|
|
private HashMap<Integer, Node> keyNodeMap;
|
|
|
// Node 串成的双向链表
|
|
|
private DoubleLinkedList nodeList;
|
|
|
// 这个结构的容量!
|
|
|
private final int capacity;
|
|
|
|
|
|
public LRUCache(int cap) {
|
|
|
keyNodeMap = new HashMap<>();
|
|
|
nodeList = new DoubleLinkedList();
|
|
|
capacity = cap;
|
|
|
}
|
|
|
|
|
|
public int get(int key) {
|
|
|
if (keyNodeMap.containsKey(key)) {
|
|
|
Node ans = keyNodeMap.get(key);
|
|
|
nodeList.moveNodeToTail(ans);
|
|
|
return ans.val;
|
|
|
}
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
// A 23
|
|
|
public void put(int key, int value) {
|
|
|
if (keyNodeMap.containsKey(key)) {
|
|
|
Node node = keyNodeMap.get(key);
|
|
|
node.val = value;
|
|
|
nodeList.moveNodeToTail(node);
|
|
|
} else {
|
|
|
// 之前没有A的记录，新增!
|
|
|
// 1) 结构满了
|
|
|
// 2) 结构没有满
|
|
|
if (keyNodeMap.size() == capacity) {
|
|
|
removeMostUnusedCache();
|
|
|
}
|
|
|
Node newNode = new Node(key, value);
|
|
|
keyNodeMap.put(key, newNode);
|
|
|
nodeList.addNode(newNode);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private void removeMostUnusedCache() {
|
|
|
Node removeNode = nodeList.removeHead();
|
|
|
keyNodeMap.remove(removeNode.key);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
