数据结构与算法——LRU缓存

一、LRU缓存

LRU（least recently used）最近最少使用缓存机制，在计算机的缓存满时，会最先淘汰近期最少使用的数据。示意图如下图所示：
设缓存的大小为5，在缓存未满之前，ABCDEF依次进入缓存。当要缓存F时，A近期没有被使用，因此淘汰掉，F放到头的位置，剩下的往后挪。当再次进来C的时候，因为缓存里已经有C了，因此把C提到缓存的头来。再进来G的时候，G放到头，剩下的往后挪。

二、实现LRU缓存

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

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

import collections
class LRUCache:
    def __init__(self, capacity: int):
        self.dic = collections.OrderedDict()
        self.remain = capacity

    def get(self, key: int) -> int:
        if key not in self.dic:
            return -1
        v = self.dic.pop(key)   # 获取指定key的value，并在字典中删除
        self.dic[key] = v       # 将key作为最新的一个
        return v

    def put(self, key: int, value: int) -> None:
        if key in self.dic:
            self.dic.pop(key)
        else:
            if self.remain > 0:
                self.remain -= 1
            else:
                # popitem(): 先进后出
                # last为False时，删除最先放进来的键值对对并返回该键值对
                self.dic.popitem(last=False)    
        self.dic[key] = value

此题用时也可以用双链表+hash表来解决，数据结构如下所示。双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的；哈希表即为普通的哈希映射，通过缓存数据的键映射到其在双向链表中的位置。

我们首先使用哈希表进行定位，找出缓存项在双向链表中的位置，随后将其移动到双向链表的头部，即可在O(1)的时间内完成get或者put操作。具体的方法如下：

• 对于get操作，首先判断key是否存在：
  • 如果key不存在则返回-1
  • 如果key存在，则key对应的节点是最近被使用的节点。通过哈希表定位到该节点在双向链表中的位置，并将其移动到双向链表的头部，最后返回该节点的值。
• 对于 put 操作，首先判断 key 是否存在：
  • 如果key不存在，使用key和value创建一个新的节点，在双向链表的头部添加该节点，并将key和该节点添加进哈希表中。然后判断双向链表的节点数是否超出容量，如果超出容量，则删除双向链表的尾部节点，并删除哈希表中对应的项；
  • 如果key存在，则与get操作类似，先通过哈希表定位，再将对应的节点的值更新为value，并将该节点移到双向链表的头部

class DLinkNode:
    def __init__(self, key=0, val=0):
        self.key = key
        self.val = val
        self.prev = None
        self.next  =None

class LRUCache:
    def __init__(self, capacity: int):
        self.hash = {}
        self.head = DLinkNode()     # 头结点
        self.tail = DLinkNode()     # 尾节点
        self.head.next = self.tail
        self.tail.next = self.head
        self.capacity = capacity
        self.size = 0

    def get(self, key: int) -> int:
        # 如果键不再hash中返回-1
        if key not in self.hash:
            return -1
        # 键在hash中，获得节点，并将其移到头部
        node = self.hash[key]
        self.move_to_head(node)
        return node.val

    def put(self, key: int, value: int) -> None:
        if key in self.hash:        # key在hash中
            node = self.hash[key]   # 获得节点
            node.val = value        # 修改节点值
            self.move_to_head(node) # 将节点移到头部
        else:   # key不在hash中
            node = DLinkNode(key, value)    # 新建节点
            self.hash[key] = node           # 将节点添加到hash索引
            self.add_to_head(node)          # 添加到头部
            self.size += 1                  # 当前链表节点数加1
            if self.size > self.capacity:   # 如果节点数超过容量
                remove = self.remove_tail() # 移除尾部节点
                self.hash.pop(remove.key)   # hash中弹出尾部节点
                self.size -= 1              # 节点数减1
    
    # 添加节点到头部
    def add_to_head(self, node):
        node.next = self.head.next
        node.prev = self.head
        self.head.next.prev = node
        self.head.next = node
    
    # 移动节点到头部
    def move_to_head(self, node):
        self.remove_node(node)
        self.add_to_head(node)
    
    # 删除节点
    def remove_node(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev
    
    # 产出尾部节点
    def remove_tail(self):
        node = self.tail.prev
        self.remove_node(node)
        return node