Leetcode 146.LRU缓存机制（LRU Cache）


Leetcode 146.LRU缓存机制

1 题目描述（Leetcode题目链接）

??运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥已经存在，则变更其数据值；如果密钥不存在，则插入该组「密钥/数据值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

进阶:

你是否可以在 O(1) 时间复杂度内完成这两种操作？

1
2
3
4
5
6
7
8
9
10
11
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

2 题解

??我们可以使用队列来实现这个次序关系，其中队头为最久未使用的，队尾表示最近使用过的：

  • 当get或put时，如果key已经在队列中，则将key移动到队列末尾
  • 当插入一个新值时，如果容量已满，则弹出队头，将新值插入到末尾，否则直接将新值插入到末尾。

问题就在于，如果在

O(1)O(1)

O(1)的时间复杂度把队列中间的值移动到末尾，因此我们可以使用双向链表+字典来实现，字典的

keykey

key就是要插入的

keykey

key，其对应的

valuevalue

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
class Listnode:
    def __init__(self, key, val):
        self.key = key
        self.val = val
        self.pre = None
        self.next = None

class LRUCache:

    def __init__(self, capacity: int):
        self.cache = {}
        # head是链表头节点
        self.head = Listnode(None, None)
        # end是链表尾结点        
        self.end = Listnode(None, None)        
        self.head.next = self.end
        self.end.pre = self.head
        self.capacity = capacity

    def get(self, key: int) -> int:
        # 如果key在cache中，则将key对应的节点移动到链表末尾
        if key in self.cache:          
            self.pick(key)
            self.insert_end(key)
            return self.cache[key].val
        return -1

    def put(self, key: int, value: int) -> None:
        # 如果key在cache中，则将key对应的节点移动到链表末尾，并更新值
        if key in self.cache:          
            self.pick(key)
            self.insert_end(key)
            self.cache[key].val = value
        else:
            # 如果key不在cache中，并且容量未到最大值，则新建节点并插入链表末尾
            if len(self.cache) < self.capacity:        
                self.cache[key] = Listnode(key, value)
                self.insert_end(key)
            else:
                # 容量到了最大值，就把链表第一个节点变成新值，然后插入链表末尾
                node = self.head.next                  
                self.cache.pop(node.key)
                node.key, node.val = key, value
                self.cache[key] = node
                self.pick(key)
                self.insert_end(key)          

    # 将key对应的节点从链表中摘出来  
    def pick(self, key):
        self.cache[key].pre.next = self.cache[key].next
        self.cache[key].next.pre = self.cache[key].pre

    # 将key对应的节点插入到链表末尾
    def insert_end(self, key):
        self.cache[key].next = self.end
        self.cache[key].pre = self.end.pre
        self.end.pre.next = self.cache[key]
        self.end.pre = self.cache[key]
       


# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)