python算法习题（六）：LFU缓存

版权声明：本文为博主原创文章，欢迎转载，但请注明原文出处。 https://blog.csdn.net/GiveMeFive_Y/article/details/79867024

1. 题目

LFU（Least Frequently Used）算法根据数据的历史访问频率来淘汰数据，其核心思想是“如果数据过去被访问多次，那么将来被访问的频率也更高”。
实现LFU中的set 和 get。
样例
capacity = 3

set(2,2)
set(1,1)
get(2)
=> 2
get(1)
=> 1
get(2)
=> 2
set(3,3)
set(4,4)
get(3)
=> -1
get(2)
=> 2
get(1)
=> 1
get(4)
=> 4

2. 思路

创建一个字典保存数据，同时创建一个列表保存key引用计数的排序。

3. 代码

class LFU():
    def __init__(self, capacity):
        self.capacity = capacity
        self.d = {}
        self.L = []

    def set(self, k , v):
        self.d[k]={}
        self.d[k]['value'] = v
        self.d[k]['count'] = 1

        if len(self.L) == 3:
            self.d.pop(self.L.pop()) # 字典pop引用计数最小的key

        self.L.append(k)
        print(self.L, self.d)

    def get(self, k):
        if not self.d.get(k, None):
            return -1
        self.d[k]['count'] += 1
        t = list(map(lambda n: (n, self.d[n]['count']), self.d)) # 取出key和count合成元组
        t.sort(key=lambda x: x[1], reverse=True) # 基于count排序
        self.L = [i[0] for i in t]
        print(self.L, self.d)
        return self.d[k]['value']

p = LFU(3)
p.set(1, 1)
p.set(2, 2)
print(p.get(1))
print(p.get(2))
print(p.get(2))
print(p.get(2))
p.set(3,3)
p.set(4,4)
print(p.get(3))
print(p.get(4))
结果：
[1] {1: {'value': 1, 'count': 1}}
[1, 2] {1: {'value': 1, 'count': 1}, 2: {'value': 2, 'count': 1}}
[1, 2] {1: {'value': 1, 'count': 2}, 2: {'value': 2, 'count': 1}}
1
[1, 2] {1: {'value': 1, 'count': 2}, 2: {'value': 2, 'count': 2}}
2
[2, 1] {1: {'value': 1, 'count': 2}, 2: {'value': 2, 'count': 3}}
2
[2, 1] {1: {'value': 1, 'count': 2}, 2: {'value': 2, 'count': 4}}
2
[2, 1, 3] {1: {'value': 1, 'count': 2}, 2: {'value': 2, 'count': 4}, 3: {'value': 3, 'count': 1}}
[2, 1, 4] {1: {'value': 1, 'count': 2}, 2: {'value': 2, 'count': 4}, 4: {'value': 4, 'count': 1}}
-1
[2, 1, 4] {1: {'value': 1, 'count': 2}, 2: {'value': 2, 'count': 4}, 4: {'value': 4, 'count': 2}}
4

4. 总结

显然这只能作为一个小程序。当大量数据需要保存的时候严重消耗内存影响性能。