LRU 缓存的实现【Java实现，力扣Leetcode146. LRU 缓存】_java 实现一个lru缓存

LRU，要做到 get 和 put 操作的 时间复杂度近似为 O(1)。我们可以想到使用 HashMap。HashMap 可以做到 get，put操作的近似 O(1)，但是怎么记录哪个值是最近最久未使用过的呢？显然HashMap 无法做到。这时候，就想到了链表。链表的插入，删除操作是O(1)的，而且我们可以定义队头的元素是最近被使用的，队尾的元素是最近最少使用的。所以，经过分析，我们可以结合 HashMap 和 LinkedList 来实现。显然，链表使用双向链表更为方便。我们可以手写一个 DoubleLinkedLIst。

具体的代码：

class LRUCache {
    // 这里定义，越靠近队头的元素，是最近被使用的。越靠近队尾的是最近最少使用的。
    private DoubleLinkedList cache;
    private Map<Integer, Node> map;
    private int size; 
    public LRUCache(int capacity) {
        cache = new DoubleLinkedList();
        map = new HashMap<>();
        size = capacity;
    }
    
    public int get(int key) {
        if (!map.containsKey(key)) {
            return -1;
        }
        // 缓存存在，注意这里要更新缓存到队头，代表最近被使用过
        int value = map.get(key).value;
        put(key, value);
        return value;
    }
    
    public void put(int key, int value) {
        Node newNode = new Node(key, value);
        // 缓存原本不存在
        if (!map.containsKey(key)) {
            // 空间满了，要剔除最近最少使用的，也就是队尾的元素
            if (map.size() == size) {
                int k = cache.deleteAtTail();
                map.remove(k);
            }
            cache.addAtHead(newNode);
            map.put(key, newNode);
        } else {
            cache.delete(map.get(key));
            cache.addAtHead(newNode);
            map.put(key, newNode);
        }
    }
}

class DoubleLinkedList {
    Node head;
    Node tail;

    public DoubleLinkedList() {
        head = new Node(0, 0);
        tail = new Node(0, 0);
        head.next = tail;
        tail.pre = head;
    }

    public void addAtHead(Node node) {
        node.pre = head;
        node.next = head.next;
        head.next.pre = node;
        head.next = node;
    }

    public int delete(Node node) {
        int key = node.key;
        node.pre.next = node.next;
        node.next.pre = node.pre;
        return key;
    }

    public int deleteAtTail() {
        return delete(tail.pre);
    }

}

class Node {
    int key;
    int value;
    Node pre;
    Node next;

    public Node(int key, int value) {
        this.key = key;
        this.value = value;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83