leetcode链表之LFU缓存

460、LFU缓存

题目：

请你为 最不经常使用（LFU）缓存算法设计并实现数据结构。

实现 LFUCache 类：

• LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象
• int get(int key) - 如果键 key 存在于缓存中，则获取键的值，否则返回 -1 。
• void put(int key, int value) - 如果键 key 已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量 capacity 时，则应该在插入新项之前，移除最不经常使用的项。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除 最近最久未使用 的键。

为了确定最不常使用的键，可以为缓存中的每个键维护一个 使用计数器 。使用计数最小的键是最久未使用的键。

当一个键首次插入到缓存中时，它的使用计数器被设置为 1 (由于 put 操作)。对缓存中的键执行 get 或 put 操作，使用计数器的值将会递增。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行

---

思路：

本来想用hash表+双向链表来做的，，使用了432、全O(1)的数据结构来方式来做操作，最后却超时了，由于在读取和插入的时候要频繁的查找插入位置，时间复杂度可以达到O(n)

后面用hash的方式将freq存储起来，记录最小的minFreq，然后采用尾部插入，头部删除。当然这里也可以不使用双向链表，使用数组也是可以的。

class DoubleLinkedNode:
    def __init__(self, key=0, value=0, freq=0, next=None, prev=None):
        self.key = key
        self.value = value
        self.freq = freq
        self.next = next
        self.prev = prev

class LFUCache:

    def __init__(self, capacity: int):
      	# 存放key和结点的映射关系，方便找到对应所在的freq队列
        self.cache = {}
        self.size = 0
        # 存放freq和当前freq的结点队列的关系
        self.freqLinked = {}
        self.capacity = capacity
        self.minFreq = 0
		# 删除结点，并判断freq队列是否为空
    def remove_node(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev
        if not node.prev.freq and not node.next.freq:
            self.freqLinked.pop(node.freq)
        return node
		# 创建linked队列，返回头尾结点，这里也可以单独用类来做
    def create_linked_list(self):
        self.head = DoubleLinkedNode()
        self.tail = DoubleLinkedNode()
        self.head.next = self.tail
        self.tail.prev = self.head
        return (self.head, self.tail)
		# 将node结点添加到prev结点之后
    def add_to_prev(self, node, prev):
        node.next = prev.next
        node.prev = prev
        prev.next.prev = node
        prev.next = node
		# 从freq队列中删除结点
    def remove_min_freq(self, freq):
        head, tail = self.freqLinked[freq]
        node = head.next
        self.remove_node(node)
        return node
		# 判断freq是否为空，
    # 1如果不存在freq则为空
    # 2如果只存在头尾结点，freq为空
    def is_empty_freq(self, freq):
        if freq not in self.freqLinked:
            return True
        head, tail = self.freqLinked[freq]
        if head.next == tail:
            self.freqLinked.pop(freq)
            return True
        return False
		# 将结点添加到freq队列中，并更新minFreq值
    def add_to_freq(self, node):
        freq = node.freq
        if freq not in self.freqLinked:
            head, tail = self.create_linked_list()
            self.freqLinked[freq] = (head, tail)
        else:
            _, tail = self.freqLinked[freq]
        self.add_to_prev(node, tail.prev)
				# 如果当前node的freq为1，由于freq最小只能为1
        # 或者minFreq比node的freq小1，说明minFreq可能是put之前的数据，所以这个是否判断minFreq所在队列是否为空，
        # 		并更新minFreq
        if node.freq == 1 or (self.minFreq == node.freq - 1 and self.is_empty_freq(self.minFreq)):
            self.minFreq = node.freq

    def incr(self, node):
        self.remove_node(node)
        node.freq += 1
        self.add_to_freq(node)
		
    # 1、判断key是否在cache中
    # 2、在原先的freq队列中删除结点， 删除结点的同时判断当前所在队列是否已空，如果已空则删除freq
    # 3、将结点加入到新的队列中，见add_to_freq方法
    # 4、更新minFreq，以备后面空间满了进行删除操作
    def get(self, key: int) -> int:
        if key not in self.cache: return -1
        node = self.cache[key]
        self.incr(node)
        return node.value
		# 1、判断key是否存在cache中
    # 1、1存在则更新结点value值，并从原先队列中删除，加入到新的队列中
    # 2、1如果不存在，则缓存该key值，并判断空间是否已满（这里如果先新增结点，可能会把新增的结点当做minFreq给删除了）。
    # 2、2如果空间已满，则根据minFreq进行结点删除，由于这里是尾部插入，所以队头是最久未使用。
    # 2、3将结点添加到对应的freq队列中 
    def put(self, key: int, value: int) -> None:
        if self.capacity <= 0: return None
        if key in self.cache:
            node = self.cache[key]
            node.value = value
            self.incr(node)
        else:
            node = DoubleLinkedNode(key, value, 1)
            self.cache[key] = node
            self.size += 1
            if self.size > self.capacity:
                self.size -= 1
                removed = self.remove_min_freq(self.minFreq)
                self.cache.pop(removed.key)
            self.add_to_freq(node)