LFU算法

最新推荐文章于 2025-02-26 00:00:00 发布

weixin_41848780

最新推荐文章于 2025-02-26 00:00:00 发布

阅读量463

点赞数

分类专栏： leetcode 文章标签： LFU leetcode

本文链接：https://blog.csdn.net/weixin_41848780/article/details/93615502

版权

leetcode 专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了一种LFU（Least Frequently Used）缓存算法的实现过程，使用C++编程语言，结合list和unordered_map数据结构，实现了缓存的获取和插入操作，同时处理了缓存容量限制和频繁度更新的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include <iostream>
#include <list>
#include <unordered_map>
using namespace std;
class LFUCache {
public:
    LFUCache(int capacity) {
    	_capacity = capacity;
        _min_frequent = 1;
    }
    struct CacheNode
    {
    	int key;
    	int value;
    	int frequent;
    };
    //此函数刚开始没有抽象出来。因为没有理解LFU写入还有修改数据
    int& touch(list<CacheNode>::iterator itr){
       	CacheNode& node = *itr;
       	int old_frequent = node.frequent;
       	int new_frequent = ++node.frequent;
       	_cache[new_frequent].splice(_cache[new_frequent].begin(), _cache[old_frequent], itr);
       	//splice厉害 抵三句 _cache[frequent].push_front(node); _cache[frequent - 1].erase(itr); _map[itr->key] = _cache[new_frequent].begin();
       	if (_cache[old_frequent].size() == 0 && _min_frequent == old_frequent){
       		_min_frequent = new_frequent;
       	}
       	return itr->value;//begin返回iterator 与之对应的front()
    }
    int get(int key) {
    	auto itr = _map.find(key);//测试后发现find快于count,itr对应的是pair
        if (itr == _map.end()) {
        	return -1;
        }
       	return touch(itr->second);
    }
    void put(int key, int value) {
        if (_capacity == 0){
        	return;
        }
        //1.查询是否存在，存在更新数据
        auto itr = _map.find(key);
        if (itr != _map.end()){
        	touch(itr->second) = value;
        }else{
        	//2.删除多余节点，更新_min_frequent
        	if (_map.size() >= _capacity) {
        	    //cout <<"_min_frequent" <<_min_frequent <<endl;
	        	int key = _cache[_min_frequent].back().key;
				//cout <<"delete:" << _cache[_min_frequent].back().value << " frequent:" << _cache[_min_frequent].back().frequent << endl;
	        	_map.erase(key);
	        	_cache[_min_frequent].pop_back();
	        	if (_cache[_min_frequent].size() == 0 && _map.size() > 0){
	        		while (_cache[++_min_frequent].size() == 0);
	        	}
        	}
            //插入节点
        	CacheNode node{key, value, 1};
        	_cache[1].push_front(node);
        	_map[key] = _cache[1].begin();
        	_min_frequent = 1;
        }
    }
    size_t _capacity;
    int _min_frequent;
    unordered_map<int, list<CacheNode> > _cache;
    unordered_map<int, list<CacheNode>::iterator> _map;
};
int main() {
	LFUCache cache = *((LFUCache *) new LFUCache(3));
	cache.put(2, 2);
	cache.put(1, 1);
	cout << cache.get(2) <<endl;    
	cout << cache.get(1) <<endl;
	cout << cache.get(2) <<endl;  
	cache.put(3, 3);   
	cache.put(4, 4);  
	cout << cache.get(3) <<endl; 
	cout << cache.get(2) <<endl;
	cout << cache.get(1) <<endl;
	cout << cache.get(4) <<endl;
	return 0;
}