版权声明:本文为博主原创文章,欢迎转载,但请注明原文出处。 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. 总结
显然这只能作为一个小程序。当大量数据需要保存的时候严重消耗内存影响性能。