码迷,mamicode.com
首页 > 编程语言 > 详细

LeetCode(460):手写LFU算法

时间:2021-01-07 12:45:33      阅读:0      评论:0      收藏:0      [点我收藏+]

标签:最小   多个   type   efi   映射   capacity   图片   key   手写   

题目描述

技术图片

实现思路

1、大致分析

依据题目,可以列举出几个显而易见的事实:

  • 调用get方法, 返回该key对应的val
  • 调用get或者put方法访问某个key,该key对应的freq加一
  • 如果在容量满了以后进行插入,则需要将freq最小的key删除,如果最小的freq对应多个key,则删除其中最旧(最早put进来)的那个

如果我们希望在O(1)的时间复杂度内解决这些需求,就要逐个击破:

  • 使用一个Map存储key到val的映射,命名为keyToVal
  • 使用一个Map存储key到freq的映射,命名为keyToFreq

为了实现“最不经常使用”的功能,我们需要:

  • 使用一个Map存储freq到key的映射,命名为freqToKeys
  • 用变量minFreq来记录当前最小的freq
  • 可能有多个key具有相同的freq,所以每个freq应该对应一个key的列表
  • 当容量已满时,我们需要淘汰最不经常使用最早被插入的key,这就要求freq对应的key列表要有时序
  • 因此,每个freq对应的key用双向链表来维护:要淘汰key时,删除链表的第一个节点;要更新key时,在链表尾部插入新节点

至此,我们就可以写出LFUcache的基本数据结构(初始化):

var LFUCache = function(capacity) {
    this.keyToVal = new Map()
    this.keyToFreq = new Map()
    this.freqToKeys = new Map()
    this.capacity = capacity
    this.minFreq = 0
};

定义节点类和双向链表类:

class Node {
    constructor(key){
        this.key = key
    }
}

class HashedList {
    constructor(){
        this.head = new Node(0)
        this.head.next = this.tail
        this.tail = new Node(0)
        this.tail.prev = this.head
        this.size = 0
    }
}

2.1、get方法

get方法的逻辑很简单:

  • 在keyToVal中查找,找不到则返回-1,找到则返回val
  • 增加key对应的freq
LFUCache.prototype.get = function(key) {
    if(!this.keyToVal.has(key)){
        return -1
    }
    this.increaseFreq(key)
    return this.keyToVal.get(key)
};

2.2、 put方法

put方法的逻辑稍微有点复杂:

  • 在keyToVal中查找key是否存在:若存在,则修改key对应的val,并增加key对应的freq
  • 若不存在:判断容量是否已满
  • 若容量已满,则淘汰一个freq最小的key
  • 更新3个哈希表
LFUCache.prototype.put = function(key, value) {
    if(this.capacity <= 0){
        return
    }

    // key已存在
    if(this.keyToVal.has(key)){
        this.keyToVal.set(key,value)
        this.increaseFreq(key)
        return
    }

    // key不存在,且容量已满
    if(this.capacity <= this.keyToVal.size){
        this.removeMinFreqKey()
    }

    // 插入key和value,对应的freq为1
    // 插入KV表
    this.keyToVal.set(key,value)
    // 插入KF表
    this.keyToFreq.set(key,1)
    // 插入FK表
    if(!this.freqToKeys.has(1)){
        let list = new HashedList()
        this.freqToKeys.set(1,list)
    }
    this.freqToKeys.get(1).addLast(key)
    this.minFreq = 1
};

要注意的是:在更新freqToKeys时,要先判断是否有freq=1的key链表

如果没有,要先创建一个空的双向链表

然后通过addLast方法,将新的key节点插入到链表尾部

addLast(key){
    let x = new Node(key)
    x.prev = this.tail.prev
    x.next = this.tail
    this.tail.prev.next = x
    this.tail.prev = x
    this.size++
}

3.1、removeMinFreqKey方法

首先通过freqToKeys 找到minFreq对应的链表 记为list

然后删除list的第一个节点

为HashedList编写一个removeFirst方法,在删除第一个节点的同时,返回其key值

removeFirst(){
    var first = this.head.next
    this.head.next = first.next
    first.next.prev = this.head
    this.size--
    return first.key
}

如果删除后,list变为空,则在freqToKeys中删除这个freq对应的映射

最后更新另外2个哈希表

LFUCache.prototype.removeMinFreqKey = function(){
    var list = this.freqToKeys.get(this.minFreq)
    var deleteKey = list.removeFirst()
    if(list.size === 0){
        this.freqToKeys.delete(this.minFreq)
    }
    this.keyToVal.delete(deleteKey)
    this.keyToFreq.delete(deleteKey)
}

为什么在删除minFreq对应的映射时,不需要更新minFreq呢?

因为removeMinFreqKey只在put方法且新插入的key不存在的时候发生,在此之后,minFreq一定为1

3.2、increaseFreq方法

首先 通过keyToFreq找到key对应的freq 记为freq

然后 更新keyToFreq

然后 更新 freqToKeys:

  • 将key从freq对应的链表中删除
  • 将key加入freq+1对应的链表中

同样地,要处理freq链表为空 以及 freq+1链表不存在的这2种特殊情况

LFUCache.prototype.increaseFreq = function(key) {
    var freq = this.keyToFreq.get(key)

    this.keyToFreq.set(key,freq+1)
    
    this.freqToKeys.get(freq).remove(key)
    
    if(!this.freqToKeys.has(freq+1)){
        let list = new HashedList()
        this.freqToKeys.set(freq+1,list)
    }
    this.freqToKeys.get(freq+1).addLast(key)
    
    if(this.freqToKeys.get(freq).size === 0){
        this.freqToKeys.delete(freq)
        if(freq === this.minFreq){
            this.minFreq++
        }
    }
}

最后,为HashedList类编写一个remove方法,从链表中删除指定key的节点

remove(key){
    var p = this.head.next
    while(p != this.tail){
        if(p.key === key){
        	break
        }
        p = p.next
    }
    
    p.prev.next = p.next
    p.next.prev = p.prev
    this.size--
}

代码实现(JavaScript)

附上完整的代码:

class Node {
    constructor(key){
        this.key = key
    }
}

class HashedList {
    constructor(){
        this.head = new Node(0)
        this.head.next = this.tail
        this.tail = new Node(0)
        this.tail.prev = this.head
        this.size = 0
    }

    addLast(key){
        let x = new Node(key)
        x.prev = this.tail.prev
        x.next = this.tail
        this.tail.prev.next = x
        this.tail.prev = x
        this.size++
    }

    remove(key){
        var p = this.head.next
        while(p != this.tail){
            if(p.key === key){
                break
            }
            p = p.next
        }
        
        p.prev.next = p.next
        p.next.prev = p.prev
        this.size--
    }

    removeFirst(){
        var first = this.head.next
        this.head.next = first.next
        first.next.prev = this.head
        this.size--
        return first.key
    }
}

var LFUCache = function(capacity) {
    this.keyToVal = new Map()
    this.keyToFreq = new Map()
    this.freqToKeys = new Map()
    this.capacity = capacity
    this.minFreq = 0
};

LFUCache.prototype.removeMinFreqKey = function(){
    var list = this.freqToKeys.get(this.minFreq)
    var deleteKey = list.removeFirst()
    if(list.size === 0){
        this.freqToKeys.delete(this.minFreq)
    }
    this.keyToVal.delete(deleteKey)
    this.keyToFreq.delete(deleteKey)
}

LFUCache.prototype.increaseFreq = function(key) {
    var freq = this.keyToFreq.get(key)

    this.keyToFreq.set(key,freq+1)
    
    this.freqToKeys.get(freq).remove(key)
    if(!this.freqToKeys.has(freq+1)){
        let list = new HashedList()
        this.freqToKeys.set(freq+1,list)
    }
    this.freqToKeys.get(freq+1).addLast(key)
    
    if(this.freqToKeys.get(freq).size === 0){
        this.freqToKeys.delete(freq)
        if(freq === this.minFreq){
            this.minFreq++
        }
    }
}

LFUCache.prototype.get = function(key) {
    if(!this.keyToVal.has(key)){
        return -1
    }
    this.increaseFreq(key)
    return this.keyToVal.get(key)
};

LFUCache.prototype.put = function(key, value) {
    if(this.capacity <= 0){
        return
    }

    if(this.keyToVal.has(key)){
        this.keyToVal.set(key,value)
        this.increaseFreq(key)
        return
    }

    if(this.capacity <= this.keyToVal.size){
        this.removeMinFreqKey()
    }

    this.keyToVal.set(key,value)
    
    this.keyToFreq.set(key,1)
    
    if(!this.freqToKeys.has(1)){
        let list = new HashedList()
        this.freqToKeys.set(1,list)
    }
    this.freqToKeys.get(1).addLast(key)
    this.minFreq = 1
};

LeetCode(460):手写LFU算法

标签:最小   多个   type   efi   映射   capacity   图片   key   手写   

原文地址:https://www.cnblogs.com/baebae996/p/14238303.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有
迷上了代码!