数据结构算法刷题（14）LRU算法、LFU算法

一、LRU算法

LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。

python中有一个标准库的类的OrderedDict，该类有以下两个方法用来实现LRU算法就十分简单：

popitem(last=True)：有序字典的 popitem() 方法移除并返回一个 (key, value) 键值对。 如果 last 值为真，则按 LIFO 后进先出的顺序返回键值对，否则就按 FIFO 先进先出的顺序返回键值对。
move_to_end(key, last=True)：将现有 key 移动到有序字典的任一端。 如果 last 为真值（默认）则将元素移至末尾；如果 last 为假值则将元素移至开头。如果 key 不存在则会触发 KeyError
 

import collections

class LRUCache:

        def __init__(self,capacity):

                self.capacity = capacity #初始化缓存容量

                self.cache = collections.OrderedDict() #使用哈希表来存缓存

        def get(self,key):

                if key in self.cache:#如果访问的值在缓存中

                        self.cache.move_to_end(key,last = True) #将该值移动到队尾

                        return self.cache[key]

                else:

                        return -1

        def put(self,key,value):

                if key in self.cache: #该值被最近访问

                        self.cache.move_to_end(key,last = True) #将该值移动到队尾

                elif len(self.cache) >= self.capacity: #队满，踢出队头（因为队尾是被最近访问过的）

                        self.cache.popitem(last = False) # 先进先出，踢出队头

                self.cache[key] = value

LFU是算法根据数据的历史访问频率来淘汰数据，其核心思想是“如果数据过去被访问多次，那么将来被访问的频率也更高”。LFU的每个数据块都有一个引用计数，所有数据块按照引用计数排序，具有相同引用计数的数据块则按照时间排序。

删除时，删除频率最小且最近不出现的

import collections

class LFUCache:

    def __init__(self, capacity: int):

        self.capacity = capacity

        self.key_and_freq = collections.defaultdict() # 记录key值和当前key出现的频率

        self.cache = collections.defaultdict(OrderedDict) # 出现频率：{key：value}

        self.minfreq = 0 #记录cache中出现频率的value不是空的最小值

    def get(self, key: int) -> int:

        if key in self.key_and_freq:

            freq = self.key_and_freq[key] #取到频率

            val = self.cache[freq].pop(key) #取到value之后，频次是freq的元素就不存在了，要更新freq

            self.key_and_freq[key] += 1 #更新当前key出现的频率

            self.cache[freq+1][key] = val #将{key:value}更新至freq+1的频次

            if self.minfreq == freq and len(self.cache[freq]) == 0:#当前key的频率是最小频率，而且cache中该频率的value是空

                self.minfreq += 1 #最小频率加一

            return val

        else:

            return -1

    def put(self, key: int, value: int) -> None:

        if key in self.key_and_freq:#逻辑和get一样，只需要更新频率和value以及minfreq

            freq = self.key_and_freq[key]

            self.cache[freq].pop(key)

            self.cache[freq+1][key] = value

            self.key_and_freq[key] += 1

            if self.minfreq == freq and len(self.cache[freq]) == 0:

                self.minfreq += 1

        else:

            if len(self.key_and_freq) == self.capacity: #缓存满，要删freq最小且最近不出现的key

                delkey, delvalue = self.cache[self.minfreq].popitem(last = False) #删缓存

                self.key_and_freq.pop(delkey) #删频次

            self.key_and_freq[key] = 1 #第一次出现

            self.cache[1][key] = value

            self.minfreq = 1