[Swift]LeetCode460. LFU缓存 | LFU Cache

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10816306.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Design and implement a data structure for Least Frequently Used (LFU) cache. It should support the following operations: get and put.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
put(key, value) - Set or insert the value if the key is not already present. When the cache reaches its capacity, it should invalidate the least frequently used item before inserting a new item. For the purpose of this problem, when there is a tie (i.e., two or more keys that have the same frequency), the least recently used key would be evicted.

Follow up:
Could you do both operations in O(1) time complexity?

Example:

LFUCache cache = new LFUCache( 2 /* capacity */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // returns 1
cache.put(3, 3);    // evicts key 2
cache.get(2);       // returns -1 (not found)
cache.get(3);       // returns 3.
cache.put(4, 4);    // evicts key 1.
cache.get(1);       // returns -1 (not found)
cache.get(3);       // returns 3
cache.get(4);       // returns 4

---

设计并实现最不经常使用（LFU）缓存的数据结构。它应该支持以下操作：get 和 put。

get(key) - 如果键存在于缓存中，则获取键的值（总是正数），否则返回 -1。
put(key, value) - 如果键不存在，请设置或插入值。当缓存达到其容量时，它应该在插入新项目之前，使最不经常使用的项目无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，最近最少使用的键将被去除。

进阶：
你是否可以在 O(1) 时间复杂度内执行两项操作？

示例：

LFUCache cache = new LFUCache( 2 /* capacity (缓存容量) */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回 1
cache.put(3, 3);    // 去除 key 2
cache.get(2);       // 返回 -1 (未找到key 2)
cache.get(3);       // 返回 3
cache.put(4, 4);    // 去除 key 1
cache.get(1);       // 返回 -1 (未找到 key 1)
cache.get(3);       // 返回 3
cache.get(4);       // 返回 4

---

Runtime: 516 ms

Memory Usage: 21.3 MB

import Foundation
class LFUCache {
    //最大容量
    var capacity:Int
    //当前容量
    var size:Int
    // key 对应的node   node是在小链表上面的
    var kNMap:[Int:Node]
    //Node对应的NodeList的头是哪个  就是任何一个小结点都能查到在大链表的哪个小链表上
    //一个链表对应的大链表的结点是哪个
    var heads:[Node:NodeList]
    //整个大链表的头部  动态的头部  不一定就是1作为头
    var headList:NodeList?
    
    init(_ capacity: Int) {
        self.capacity = capacity
        self.size = 0
        kNMap = [Int:Node]()
        heads = [Node:NodeList]()
        headList = nil
    }
    
    func get(_ key: Int) -> Int {
        //特判一下
        if capacity == 0 {return -1}
        if kNMap[key] == nil {return -1}
        //获取结点所在的原来的链表
        if let node:Node = kNMap[key]
        {
            node.times += 1
            //找到这个结点属于的小链表
            if let curNodeList:NodeList = heads[node]
            {
                move(node, curNodeList)
            }
            //返回对应的node的值
            return node.val
        }
        return -1        
    }
    
    func put(_ key: Int, _ val: Int) {
        //注意特判
        if capacity == 0 {return}
        //如果已经存在  就要更新值
        if kNMap[key] != nil
        {
            let node:Node = kNMap[key]!
            node.val = val
            node.times += 1
            //找到属于哪一个大链表
            
            if let curNodeList = heads[node]
            {
                /**
                 * move方法
                 * 就是在一个大链表中，和自己的上下级解耦，然后放到下一个词频链表中
                 * 比如说现在是5 times链上的，则从5times链中拿出来，如果6存在,放到6times链的头部(头插法)
                 * 如果6不存在，建出6times的链表
                 */
                move(node, curNodeList)
            }
        }
            //kNMap中不存在,是新插入的  没包含
        else
        {
            //要先判断容量够不够,已经满了  要删掉一个结点
            if size == capacity
            {
                //要删掉的就是作为大链表的 头部的尾结点  (次数最少的 用了最久的)
                if let deNode = headList?.tail
                {
                    headList?.deleteNode(deNode)
                    /**
                     * 如果我删掉了  这个deNode  有可能我整个大链表的headList都没有东西了，整个大Node要删掉，要更新大headList
                     * 又因为加入了新节点，所以又要更新headList
                     * 先删再加
                     */
                    if headList != nil
                    {
                        modifyHeadList(headList!)
                    }
                    //不要忘记在kNMap中删掉
                    kNMap[deNode.key] = nil
                    heads[deNode] = nil
                    size -= 1
                }
            }
            //新建  次数为1
            let node = Node(key, val, 1)
            
            //整个大链表都不存在
            if headList == nil
            {
                //建出大链表的头部
                headList = NodeList(node)
            }
            else
            {
                //  已经有了大链表的头部
                /**
                 * 如果有 次数为1的头  就直接添加到大头的头部
                 * 如果没有次数为1大头  就建一个大头   然后添加到大头的尾部
                 */
                //大链表的头的头 的次数是 1 也就是说 有为times的小链表
                if headList?.head?.times == 1
                {
                    //加到这里
                    headList?.addNodeFromHead(node)
                }
                else
                {
                    //没有times为 1 的小链表  要自己建一个
                    //建出一个times为1的小链表
                    let newList = NodeList(node)
                    newList.next = headList
                    headList?.pre = newList
                    headList = newList
                }
            }
            //最后再添加这条记录
            kNMap[key] = node
            heads[node] = headList
            size += 1
        }
    }
    
    /**
     * 解耦原来的链表  并放入到一个新的链表中
     *
     * @param node        这个node
     * @param oldNodeList node 的原来属于的list
     */
    func move(_ node:Node?,_ oldNodeList:NodeList)
    {
        //老链表你自己先删掉
        oldNodeList.deleteNode(node)
        
        let preList = modifyHeadList(oldNodeList) ? oldNodeList.pre : oldNodeList
        //要去的地方
        let nextList = oldNodeList.next
        
        //你的oldNodeList是大链表的最后一个
        if nextList == nil
        {
            //建一个
            let newList = NodeList(node)
            if preList != nil
            {
                preList?.next = newList
            }
            newList.pre = preList
            if headList == nil
            {
                headList = newList
            }
            if node != nil
            {
                heads[node!] = newList
            }
        }
            //不是最后一个不是times最高的
        else
        {
            //下一个存在　　就直接挂在下一个的头部
            if nextList?.head?.times == node?.times
            {
                nextList?.addNodeFromHead(node)
                if node != nil
                {
                    heads[node!] = nextList
                }
            }
                //下一个不是 times + 1的   要自己新建一个node　　然后左右两边重新连接好
            else
            {
                let newList = NodeList(node)
                
                if preList != nil
                {
                    preList?.next = newList
                }
                newList.pre = preList
                newList.next = nextList
                nextList?.pre = newList
                //这个是也要更换头
                if headList == nextList
                {
                    headList = newList
                }
                if node != nil
                {
                    heads[node!] = newList
                }
            }
        }
    }
    
    /**
     * 这个方法的调用时机是  把一个node从一个nodelist中删掉 ，然后判断是不是要不这个nodelist给删掉
     * 就是在delete之后， 要不要把整个小链表删掉
     *
     * @param nodeList
     */
    func modifyHeadList(_ nodeList:NodeList) -> Bool
    {
        //为空了才要删掉整个大链表中的这个结点
        if nodeList.isEmpty()
        {
            //要删的这个  是整个大链表的头部
            if headList == nodeList
            {
                //新的头部是老头部的下一个
                headList = headList?.next
                if headList != nil
                {
                    headList?.pre = nil
                }
            }
            else
            {
                //要删的不是头
                nodeList.pre?.next = nodeList.next
                if nodeList.next != nil
                {
                    nodeList.next?.pre = nodeList.pre
                }
            }
            //也就是 这个是要整个都要删掉的
            return true
        }
        //不空的话(也就是不只一个)就不要删    留着
        return false
    }
}
//小链表(挂在下面的)
class Node:Hashable
{
    static func == (lhs: Node, rhs: Node) -> Bool {
        return lhs.key == rhs.key
    }
    
    func hash(into hasher: inout Hasher)
    {
        hasher.combine(key)
    }
    //map中push的key
    var key:Int
    //map中对应的value
    var val:Int
    //操作的次数
    var times:Int
    //小链表的上一个
    var up:Node?
    //小链表的下一个
    var down:Node?
    
    init(_ key:Int,_ val:Int,_ times:Int)
    {
        self.key = key
        self.val = val
        self.times = times
    }
}

//大的链表的结点结构  (每一个结点都是一个小链表)
class NodeList:Hashable
{
    static func == (lhs: NodeList, rhs: NodeList) -> Bool {
        return lhs.head == rhs.head && lhs.tail == rhs.tail 
    }
    
    func hash(into hasher: inout Hasher)
    {
        hasher.combine(head)
        hasher.combine(tail)
    }
    
    //大链表的头部指针
    var head:Node?
    //大链表的尾部指针
    var tail:Node?
    //大链表的前一个结点
    var pre:NodeList?
    //大链表的下一个结点
    var next:NodeList?
    
    init(_ node:Node?)
    {
        self.head = node
        self.tail = node
    }
    
    //返回这个小链表(小链表本身又是大链表的结点)是不是空的
    func isEmpty() -> Bool
    {
        return head == nil
    }
    
    //小链表的头部添加结点
    func addNodeFromHead(_ newHead:Node?)
    {
        newHead?.down = head
        head?.up = newHead
        head = newHead
    }
    
    //删除小链表中的任意一个结点
    func deleteNode(_ node:Node?)
    {
        //只有一个结点
        if head == tail
        {
            head = nil
            tail = nil
        }
        else
        {
            //删除的是小链表的头部
            if head  == node
            {
                //头结点变成下一个
                head = head?.down
                //头结点的上一个 置空
                head?.up = nil
            }
                //删除的是小链表的尾部
            else if tail  == node
            {
                tail = tail?.up
                tail?.down = nil
            }
                //删除的是链表的中间
            else
            {
                node?.up?.down = node?.down
                node?.down?.up = node?.up
            }
        }
        //完全断链
        node?.up = nil
        node?.down = nil
    }
}
/**
 * Your LFUCache object will be instantiated and called as such:
 * let obj = LFUCache(capacity)
 * let ret_1: Int = obj.get(key)
 * obj.put(key, value)
 */

---

424ms

class LFUCache {

    var capacity: Int
    var count: Int
    var min: Int
    var nodeMap: [Int: DLNode]
    var countMap: [Int: DLList]
    init(_ capacity: Int) {
        self.capacity = capacity
        self.count = 0
        self.min = Int.max
        self.nodeMap = [Int: DLNode]()
        self.countMap = [Int: DLList]()
    }
    
    func get(_ key: Int) -> Int {
      if let node = nodeMap[key] {
          updateNode(node)
          return node.value
      }
        else {
            return -1
        }
    }
    
    func put(_ key: Int, _ value: Int) {
      guard capacity > 0 else { return }
        if let node = nodeMap[key] {
            node.value = value
            updateNode(node)
        } else {
            if count == capacity {
                if let minList = countMap[min] {
                    let removed = minList.removeLast()
                    nodeMap[removed.key] = nil
                    count -= 1
                }
            }
            let node = DLNode(key, value)
            nodeMap[key] = node
            if let firstList = countMap[1] {
                firstList.add(node)
            } else {
                countMap[1] = DLList(node)
            }
            count += 1
            min = 1
        }
    }
    private func updateNode(_ node: DLNode) {
        if let list = countMap[node.count] {
            list.remove(node)
            if node.count == min, list.isEmpty {
                min += 1
            }
            node.count += 1
            if let newList = countMap[node.count] {
                newList.add(node)
            } else {
                countMap[node.count] = DLList(node)
            }
        }
    }

}
     

    

class DLNode {
    var key: Int
    var value: Int
    var count: Int
    var pre: DLNode?
    var next: DLNode?
    init(_ key: Int, _ value: Int) {
        self.key = key
        self.value = value
        count = 1
    }
}

class DLList {
    var head: DLNode
    var tail: DLNode
    var isEmpty: Bool {
        return head.next === tail && tail.pre === head
    }
    init(_ node: DLNode) {
        head = DLNode(0, 0)
        tail = DLNode(0, 0)
        head.next = node
        node.pre = head
        node.next = tail
        tail.pre = node
        
    }
    func add(_ node: DLNode) {
        node.pre = head
        node.next = head.next
        node.next?.pre = node
        head.next = node
    }
    func remove(_ node: DLNode) {
        node.pre?.next = node.next
        node.next?.pre = node.pre
    }
    func removeLast() -> DLNode {
        let node = tail.pre!
        remove(node)
        return node
    }
}

/**
 * Your LFUCache object will be instantiated and called as such:
 * let obj = LFUCache(capacity)
 * let ret_1: Int = obj.get(key)
 * obj.put(key, value)
 */

---

448ms

class LFUCache {
    
    private let capacity: Int
    private var nodeMap = [Int: CacheNode]()
    private var listMap = [Int: CacheList]()
    private var size = 0
    private var leastFrequency = 1

    init(_ capacity: Int) {
        self.capacity = capacity
    }
    
    func get(_ key: Int) -> Int {
        guard let node = nodeMap[key], let list = listMap[node.count] else {
            return -1
        }
        updateExsit(node: node)
        return node.val
    }
    
    func put(_ key: Int, _ value: Int) {
        if capacity == 0 {
            return
        }
        
        if let node = nodeMap[key], let list = listMap[node.count] {
            node.val = value
            updateExsit(node: node)
        } else {
            removeCacheIfNeeded()
            
            let node = CacheNode(key, value)
            nodeMap[key] = node
            listMap(add: node)
            
            size += 1
            leastFrequency = 1
        }
    }
    
    private func updateExsit(node: CacheNode) {
        guard let list = listMap[node.count] else {
            return
        } 
        list.remove(node)
        
        if list.isEmpty {
            listMap[node.count] = nil

            if leastFrequency == node.count {
                leastFrequency += 1
            }
        }
            
        node.count += 1
        listMap(add: node)
    }
    
    private func removeCacheIfNeeded() {
        guard size >= capacity, let list = listMap[leastFrequency], let key = list.removeLast()?.key else {
            return
        }
        size -= 1
        nodeMap[key] = nil
        if list.isEmpty {
            listMap[leastFrequency] = nil
        }
    }
        
    private func listMap(add node: CacheNode) {
        let list = listMap[node.count, default: CacheList()]
        list.add(node)
        listMap[node.count] = list
    }
    
}

class CacheList {
    
    private let head = CacheNode(0, 0)
    private let tail = CacheNode(0, 0)
    private var count = 0
    
    var isEmpty: Bool {
        return count <= 0
    }
    
    init() {
        head.next = tail
        tail.pre = head
    }
    
    func add(_ node: CacheNode) {
        head.next?.pre = node
        node.next = head.next
        node.pre = head
        head.next = node
        count += 1
    }
    
    
    func remove(_ node: CacheNode) {
        node.pre?.next = node.next
        node.next?.pre = node.pre
        node.next = nil
        node.pre = nil
        count -= 1
    }
    
    func removeLast() -> CacheNode? {
        guard !isEmpty, let node = tail.pre else {
            return nil
        }
        remove(node)
        return node
    }
    
}

class CacheNode {
    let key: Int
    var val: Int
    var pre: CacheNode?
    var next: CacheNode?
    var count = 1
    
    init(_ key: Int, _ val: Int) {
        self.key = key
        self.val = val
    }
}

/**
 * Your LFUCache object will be instantiated and called as such:
 * let obj = LFUCache(capacity)
 * let ret_1: Int = obj.get(key)
 * obj.put(key, value)
 */

---

500ms

class Node: CustomStringConvertible {
    var key: Int
    var val: Int
    var next: Node?
    var prev: Node?
    init(_ key: Int, _ val: Int) {
        self.key = key
        self.val = val
    }
    var description: String {
        return "((val))"
    }
}

class FreqNode: CustomStringConvertible {
    var freq: Int
    var next: FreqNode?
    var prev: FreqNode?
    var head = Node(-1, -1)
    var tail = Node(-1, -1)
    var nodeMap = [Int: Node]() // key to node
    var count: Int {
        return nodeMap.count
    }
    init(_ freq: Int) {
        self.freq = freq
        head.next = tail
        tail.prev = head
    }
    var description: String {
        var str = "f:(freq) ["
        var c = nodeMap.count
        for (key, val) in nodeMap {
            str += "(key):(val.key)"
            c -= 1
            if c != 0 {
                str += ","
            }
        }
        str += "] "
        var node: Node? = head
        while let n = node {
            if n !== head, n !== tail {
                let ptr = n.next === tail ? "" : "->"
                str += "(n)(ptr)"
            }
            node = n.next
        }
        return "{ " + str + " }"
    }
}

class LFUCache: CustomStringConvertible {
    private var capacity: Int
    private var head = FreqNode(-1)
    private var tail = FreqNode(-1)
    private var freqMap = [Int: FreqNode]() // key to freq node
    private var count: Int = 0
    var description: String {
        var str = "c:(count), ["
        var c = freqMap.count
        for (key, val) in freqMap {
            str += "(key):(val.freq)"
            c -= 1
            if c != 0 {
                str += ","
            }
        }
        str += "]  "
        var fNode: FreqNode? = head
        while let f = fNode {
            if f !== head, f !== tail {
                let ptr = f.next === tail ? "" : " --> "
                str += "(f)(ptr)"
            }
            fNode = f.next
        }
        return str
    }

    init(_ capacity: Int) {
        self.capacity = capacity
        head.next = tail
        tail.prev = head
    }

    func get(_ key: Int) -> Int {
        if capacity <= 0 { return -1 }
        guard let freqNode = freqMap[key],
            let node = freqNode.nodeMap[key] else {
                return -1
        }
        access(key, freqNode, node, false)
        return node.val
    }

    func put(_ key: Int, _ value: Int) {
        if capacity <= 0 { return }
        let isNew = freqMap[key] == nil || freqMap[key]?.nodeMap[key] == nil
        let freqNode = freqMap[key]
        let node = freqNode?.nodeMap[key] ?? Node(key, value)
        node.key = key
        node.val = value
        access(key, freqNode, node, isNew)
    }

    private func access(_ key: Int, _ freqNode: FreqNode?, _ node: Node, _ isNew: Bool) {
        if isNew {
            count += 1
        }
        if count > capacity {
            if tail.prev?.count == 1 { // remove the entire freq node
                if let key = tail.prev?.nodeMap.keys.first {
                    freqMap[key] = nil
//                    print("=======1. evicting (key)")
                }
                tail.prev?.prev?.next = tail
                tail.prev = tail.prev?.prev
            } else { // remove node only
                let t = tail.prev?.tail
                let last = tail.prev?.tail.prev
                if let key = last?.key {
                    tail.prev?.nodeMap[key] = nil
                    freqMap[key] = nil
//                    print("=======2. evicting (key)")
                }
                last?.prev?.next = t
                t?.prev = last?.prev
            }
            count -= 1
        }

        let newFreq = (freqNode?.freq ?? 0) + 1
        var newFreqNode: FreqNode
        if let freqNode = freqNode,
            freqNode.count == 1,
            freqNode.prev?.freq != newFreq { // use current node
            freqNode.freq = newFreq
            newFreqNode = freqNode
        } else {
            if let prev = freqNode?.prev,
                prev.freq == newFreq { // use prev node
                newFreqNode = prev
            } else { // create new node
                if let freqNode = freqNode { // insert the new node before
                    newFreqNode = FreqNode(newFreq)
                    newFreqNode.prev = freqNode.prev
                    newFreqNode.next = freqNode
                    freqNode.prev?.next = newFreqNode
                    freqNode.prev = newFreqNode
                } else if let last = tail.prev, last.freq == 1 { // use tail
                    newFreqNode = last
                } else { // append to tail
                    newFreqNode = FreqNode(1)
                    newFreqNode.prev = tail.prev
                    newFreqNode.next = tail
                    tail.prev?.next = newFreqNode
                    tail.prev = newFreqNode
                }
            }
            // remove node from old freq node
            freqNode?.nodeMap[key] = nil
            node.prev?.next = node.next
            node.next?.prev = node.prev
            node.next = nil
            node.prev = nil
            if freqNode?.count == 0 {
                freqNode?.prev?.next = freqNode?.next
                freqNode?.next?.prev = freqNode?.prev
                freqMap[key] = nil
            }
        }
        // update node order in new freq node
        freqMap[key] = newFreqNode
        if newFreqNode.nodeMap[key] == nil {
            node.next = newFreqNode.head.next
            node.prev = newFreqNode.head
            newFreqNode.head.next?.prev = node
            newFreqNode.head.next = node
        }
        newFreqNode.nodeMap[key] = node
    }
}

---

512ms

class LFUCache {
    var cap: Int
    var map : [Int: Node] // key, node
    var fmap : [Int: NodeList]  // count , list
    // var max : Int
    var min : Int
    init(_ capacity: Int) {
        cap = capacity
        map = [Int: Node]()
        fmap = [Int: NodeList]()
        min = 0
    }
    
    func get(_ key: Int) -> Int {
        // print("get (key)")
        if let node = map[key]{
            let list = fmap[node.count]!
            list.removeNode(node)
            if list.isEmpty() && min == node.count{
                fmap[node.count] = nil
                min += 1
            }
            node.count += 1
            if let nextList = fmap[node.count]{
                nextList.addFirst(node)
            }else{
                let nextList = NodeList()
                nextList.addFirst(node)
                fmap[node.count] = nextList
            }
            return node.val
        }else{
            return -1
        }
    }
    
    func put(_ key: Int, _ value: Int) {
        // print("put(key)")
        guard cap > 0 else { return }
        if let node = map[key]{
            let list = fmap[node.count]!
            list.removeNode(node)
            if list.isEmpty() && min == node.count{
                fmap[node.count] = nil
                min += 1
            }
            node.count += 1
            node.val = value
            if let nextList = fmap[node.count]{
                nextList.addFirst(node)
            }else{
                let nextList = NodeList()
                nextList.addFirst(node)
                fmap[node.count] = nextList
            }
        }else{
            if map.keys.count == cap{
                if let list = fmap[min]{
                    let last = list.removeLast()
                    if list.isEmpty() {
                        fmap[min] = nil
                    }
                    map[last.key] = nil
                }
            }
            var newNode = Node(value,key)
            map[key] = newNode
            if let nextList = fmap[1]{
                nextList.addFirst(newNode)
            }else{
                let nextList = NodeList()
                nextList.addFirst(newNode)
                fmap[1] = nextList
            }
            min = 1
        }        
    }    
}

class Node{
    var next : Node? = nil
    var pre : Node? = nil
    var val : Int
    var key: Int
    var count = 1
    
    init(_ value : Int, _ key: Int){
        self.val = value
        self.key = key
    }
}

class NodeList{
    var head = Node(0,0)
    var tail = Node(0,0)
    
    init() {
        head.next = tail
        tail.pre = head
    }
    
    func addFirst(_ node: Node){
        let curr = head.next!
        head.next = node
        node.next = curr
        curr.pre = node
        node.pre = head
    }
    
    func removeNode(_ node: Node){
        let pre = node.pre!
        let next = node.next! 
        next.pre = pre
        pre.next = next
    }
    
    func removeLast()-> Node{
        let last = tail.pre!
        removeNode(last)
        return last
    }

    func isEmpty() -> Bool {
        if head.next === tail {
            return true
        }
        return false
    }
}

/**
 * Your LFUCache object will be instantiated and called as such:
 * let obj = LFUCache(capacity)
 * let ret_1: Int = obj.get(key)
 * obj.put(key, value)
 */