LintCode 24. LFU缓存

原创 2018年04月15日 13:07:45
LFU是一个著名的缓存算法

实现LFU中的set 和 get

public class LFUCache {
    private Map<Integer, Node> cache;
    private int capacity = 0;
    private int used = 0;
    /*
     * @param capacity: An integer
     */
    public LFUCache(int capacity) {
        // do intialization if necessary
        cache = new HashMap<>(capacity*2);
        this.capacity = capacity;
    }

    /*
     * @param key: An integer
     * @param value: An integer
     * @return: nothing
     */
    public void set(int key, int value) {
        // write your code here
        Node n = cache.get(key);
        if (n != null) {
            n.value = value;
            n.usedTimes++;
            n.lastUsedTime = System.nanoTime();
        } else {
            n = new Node();
            n.value = value;
            n.usedTimes = 0;
            n.lastUsedTime = System.nanoTime();
            if (used < capacity) {
                cache.put(key, n);
                used++;
            } else {
                removeLast();
                cache.put(key, n);
            }
        }
    }

    /*
     * @param key: An integer
     * @return: An integer
     */
    public int get(int key) {
        // write your code here
        Node n = cache.get(key);
        if (n != null) {
            n.usedTimes = n.usedTimes + 1;
            n.lastUsedTime = System.nanoTime();
            return n.value;
        } else {
            return -1;
        }
    }

    private void removeLast() {
        int minCount = Integer.MAX_VALUE;
        long time = System.nanoTime();

        Integer k = null;
        for (Map.Entry<Integer, Node> entry : cache.entrySet()) {
            if (entry.getValue().usedTimes < minCount || (entry.getValue().usedTimes == minCount && entry.getValue().lastUsedTime < time)) {
                k = entry.getKey();
                minCount = entry.getValue().usedTimes;
                time = entry.getValue().lastUsedTime;
            }
        }
        cache.remove(k);
    }

    public class Node {
        public int value;
        public int usedTimes;
        public long lastUsedTime;
    }
}

Lintcode24 LFU Cache solution 题解

【题目描述】 LFU (Least Frequently Used) is a famous cache eviction algorithm.For a cache with capaci...
  • jane_silva
  • jane_silva
  • 2017-04-16 20:52:38
  • 376

(lintcode)第24题 LFU缓存

LFU是一个著名的缓存算法,实现LFU中的set 和 get样例:capacity = 3set(2,2) set(1,1) get(2) &amp;gt;&amp;gt; 2 get(1) &amp...
  • Aphysia
  • Aphysia
  • 2017-09-07 19:22:27
  • 491

LFU(Least Frequently Used) C++ 实现

LFU, Least Frequently Used 作为web caching系统常用的淘汰算法广泛使用, 这里利用queue + hashset + hashmap 实现LFU算法。时间复杂度in...
  • AddisionYoung
  • AddisionYoung
  • 2016-01-24 21:36:33
  • 1193

LintCode-LRU缓存策略

为最近最少使用(LRU)缓存策略设计一个数据结构,它应该支持以下操作:获取数据(get)和写入数据(set)。 获取数据get(key):如果缓存中存在key,则获取其数据值(通常是正数),否则返回...
  • wangyuquanliuli
  • wangyuquanliuli
  • 2015-08-08 13:46:09
  • 1718

LFU缓存实现

LFU缓存实现 struct LFUObject { int freq; int key; int value; LFUObject* next; LFU...
  • weixin_36346463
  • weixin_36346463
  • 2018-01-20 21:29:39
  • 56

缓存淘汰算法 —— LFU-Aging(Java实现)

Java实现,用HashMap保存key值 : 命中次数与上次命中时间。 import java.util.*; public class LFUAgingMap extends HashMap {...
  • definite_things
  • definite_things
  • 2015-05-14 00:52:13
  • 3873

两种常见的缓存淘汰算法LFU&LRU

1. LFU 1.1. 原理 LFU(Least Frequently Used)算法根据数据的历史访问频率来淘汰数据,其核心思想是“如果数据过去被访问多次,那么将来被访问的频率也...
  • jake_li
  • jake_li
  • 2016-02-13 21:47:30
  • 8609

java动态缓存成长小纪(二)——缓存算法的实现:LRU、LFU、FIFO

缓存算法也叫作淘汰算法,主要是为了当JVM空间不足时,用来清理掉缓存的。那么要清理的话,我们先清理掉哪些缓存呢?按照正常人的思维,当然是接下来一段时间内不大可能用到的缓存啦!根据这个思路,我们需要做出...
  • u011680348
  • u011680348
  • 2015-08-14 11:17:36
  • 3057

Lintcode 24 LFU缓存

LFU是一个著名的缓存算法实现LFU中的set 和 get样例capacity = 3set(2,2) set(1,1) get(2) &amp;gt;&amp;gt; 2 get(1) &amp;g...
  • u012833261
  • u012833261
  • 2018-03-13 17:42:13
  • 8

简单的java缓存实现(LRU,LFU,FIFO)

原帖地址:http://my.oschina.net/u/866190/blog/188712 提到缓存,不得不提就是缓存算法(淘汰算法),常见算法有LRU、LFU和FIFO等算法,每种算法各有...
  • yangpl_tale
  • yangpl_tale
  • 2015-04-11 20:13:00
  • 1325
收藏助手
不良信息举报
您举报文章:LintCode 24. LFU缓存
举报原因:
原因补充:

(最多只允许输入30个字)