LRU 还是有用的，缓存管理的时候，有时用到。内存有限，聚焦在重点的资源上

（还有面试）

学习 LRU, 首先要建立直观的认识

LRU 的描述很简洁，容量有限，最近使用到的资源，排前面。

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作：获取数据 get 和写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。

写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。

模拟一下

下面有两个绿色的格子，代表这个 LRU 的容量，是两个

先放节点 1 ，容量 2，当前是空的，直接放

再放节点 2 ，容量 2，当前个数 1，可以直接放

然后读取节点 1，当前哈希表中有，返回正常，该节点为最新使用节点

放入节点 3，当前个数达到容量，需要删除一个最久使用的，才能插入新的。

怎么删除，从当前节点出发，顺着箭头数。数到容量个数的，不重复节点，就都要的。（记得跳过，读取不到值的节点）

数到容量个数的，不重复节点的，前面的那一个不重复节点，就是要被删除的。（记得跳过，读取不到值的节点）

因为当前节点，是最新使用的，越是箭头方向，越是以前有用到，（同一元素，第一次数到，为有效）

删除节点 2

读取节点 2，发现取不到，返回 -1

最终：

数据结构部分:

采用了哈希表（ Swift 中的字典）和双链表。

Key - Value 存取，当然要用哈希表。

要保证新插入和新使用的元素在前，很久没使用的元素在后，可以来一个链表。

头部元素，最近使用。尾部方向元素，最近越来越少用到

元素个数超过了容量，就要删除尾部元素，需要有一个尾指针记录，有了尾指针，要删除最后的元素，就要找到他的上一个指针来操作，就要有前驱。（或者上一个指针的上一个来操作）

有了前驱。链表元素自然要找到他的下一个，也就是后继。（链表的固有属性）

链表存在前驱与后继，就是双链表了。

另一角度，双链表里面的节点，可以轻松实现自删除，不需要其他指针的协助

简单粗暴，实现一个 LRU, O ( 1 ) 复杂度

LRU 可以简单分为两部分，数据的写入与读取

先实现写入，写入了，进程里面才有数据，方便调试读取

设计存入的部分

分情况处理，

如果要插入的元素，已经在链表里面了，根据 key.

要维持链表的 LRU 有序，就要把他放在最前面，就要改他的前后指针，以及相关节点的。

先删除他，再把他插入头节点，

还要更新他的 value, 也许这个 key 的值变了。

如果要插入的元素，不在链表里面了，根据 key.

又要考虑三种情况，

如果是插入第一个元素，要先建立结构，假的头部节点，后面是假的尾节点

如果已经存在的元素满了，要删除最后面的元素，也就是最近少用到的

最后一种情况，一切正常。把新的节点，插入头部第一个。



class DLinkedNode {
    // 这个是，删除尾节点，要同步哈希表。哈希表也要对应删除的时候，用到
    let key: Int
    var val: Int
    var prior: DLinkedNode?
    var next: DLinkedNode?
    
    init(_ key: Int, value: Int) {
        self.key = key
        val = value
    }

}


class LRUCache {
    
    var dummyHead = DLinkedNode(0, value: 0)
    var dummyTail = DLinkedNode(0, value: 0)
    var capacity: Int
    var container = [Int: DLinkedNode]()
    var hasCount: Int = 0

    init(_ capacity: Int) {
        self.capacity = capacity
    }
    
    func put(_ key: Int, _ value: Int) {
       // 先设计存的部分
    }
    
    func insertHead(_ node: DLinkedNode){
        let former = dummyHead.next
        former?.prior = node
        dummyHead.next = node
        node.prior = dummyHead
        node.next = former
    }
    
    func deleteNode(_ node: DLinkedNode){
        node.prior?.next = node.next
        node.next?.prior = node.prior
        node.prior = nil
        node.next = nil
    }
    
    func deleteTail(){
        if let toDel = dummyTail.prior{
            toDel.prior?.next = dummyTail
            dummyTail.prior = toDel.prior
            container.removeValue(forKey: toDel.key)
        }
    }
}

设计读取的部分

读取部分，相对简单

哈希表中没有 key, 就返回 -1 ，没有

哈希表中存在 key，就找到对应的节点，返回值。同时把该节点更新到头部第一个节点。也就是在链表中，先删除，再插入到头部。



class DLinkedNode {
    let key: Int
    var val: Int
    var prior: DLinkedNode?
    var next: DLinkedNode?
    
    init(_ key: Int, value: Int) {
       self.key = key
        val = value
    }

}


class LRUCache {
    
    var dummyHead = DLinkedNode(0, value: 0)
    var dummyTail = DLinkedNode(0, value: 0)
    // 这个记录设定的容量
    var capacity: Int
    var container = [Int: DLinkedNode]()
   // 这个记录实际的元素个数
    var hasCount: Int = 0

    init(_ capacity: Int) {
        self.capacity = capacity
    }
    
    func get(_ key: Int) -> Int {
     // 再设计取的部分
    }

    func put(_ key: Int, _ value: Int) {
        if let node = container[key]{
            // 包含，就换顺序
            // 还有一个更新操作
            node.val = value
            deleteNode(node)
            insertHead(node)
        }
        else{
            if hasCount == 0{
                // 建立结构
                dummyHead.next = dummyTail
                dummyTail.prior = dummyHead
            }
            if hasCount >= capacity{
                // 超过，就处理
                hasCount -= 1
                deleteTail()
            }
            hasCount += 1
            // 不包含，就插入头节点
            let node = DLinkedNode(key, value: value)
            insertHead(node)
            container[key] = node
        }
    }
    
    func insertHead(_ node: DLinkedNode){
        let former = dummyHead.next
        former?.prior = node
        dummyHead.next = node
        node.prior = dummyHead
        node.next = former
    }
    
    func deleteNode(_ node: DLinkedNode){
        node.prior?.next = node.next
        node.next?.prior = node.prior
        node.prior = nil
        node.next = nil
    }
    
    func deleteTail(){
        if let toDel = dummyTail.prior{
            toDel.prior?.next = dummyTail
            dummyTail.prior = toDel.prior
            container.removeValue(forKey: toDel.key)
        }
    }
}

可以看出，LRU 的性能关键, 在于采用结构记录与保持

这里就是，链表的头部和尾部，一直都有更新。链表元素的顺序，符合 LRU

每次存取，都对链表做了更新（除了取的时候，key 不存在）

方便调试，会更好。重写了 NSObject 的 var description.

最后的完整版本：

优化一点，假的头节点和尾节点的链表关系结构，可以一开始就建好，不用以后每次写元素，都判断


class DLinkedNode: NSObject {
    let key: Int
    var val: Int
    var prior: DLinkedNode?
    var next: DLinkedNode?
    
    init(_ key: Int, value: Int) {
       self.key = key
        val = value
    }
    // 辅助调试 debug, 打印出信息的，方便看
    override var description: String{
        var result = String(val)
        var point = prior
        while let bee = point{
            result = "\(bee.val) -> " + result
            point = bee.prior
        }
        point = next
        while let bee = point{
            result = result + "-> \(bee.val)"
            point = bee.next
        }
        return result
    }
}




class LRUCache {
    // 怎样化 O ( n ) 为 O ( 1 ). 关心的状态，都用一个专门的指针，记录了
    var dummyHead = DLinkedNode(0, value: 0)
    var dummyTail = DLinkedNode(0, value: 0)
    var capacity: Int
    var container = [Int: DLinkedNode]()
    var hasCount: Int = 0

    init(_ capacity: Int) {
        self.capacity = capacity
          // 建立结构
          dummyHead.next = dummyTail
          dummyTail.prior = dummyHead
    }
    
    func get(_ key: Int) -> Int {
        // 有一个刷新机制
        if let node = container[key]{
            deleteNode(node)
            insertHead(node)
            return node.val
        }
        else{
            return -1
        }
    }
    
    func put(_ key: Int, _ value: Int) {
        if let node = container[key]{
            // 包含，就换顺序
            // 还有一个更新操作
            node.val = value
            deleteNode(node)
            insertHead(node)
        }
        else{
            if hasCount >= capacity{
                // 超过，就处理
                hasCount -= 1
                deleteTail()
            }
            hasCount += 1
            // 不包含，就插入头节点
            let node = DLinkedNode(key, value: value)
            insertHead(node)
            container[key] = node
        }
    }
    
    func insertHead(_ node: DLinkedNode){
        let former = dummyHead.next
        former?.prior = node
        dummyHead.next = node
        node.prior = dummyHead
        node.next = former
    }
    
    // 指针操作，最好还是弄个变量，接一下
    func deleteNode(_ node: DLinkedNode){
        node.prior?.next = node.next
        node.next?.prior = node.prior
        node.prior = nil
        node.next = nil
    }
    
    func deleteTail(){
        if let toDel = dummyTail.prior{
            toDel.prior?.next = dummyTail
            dummyTail.prior = toDel.prior
            container.removeValue(forKey: toDel.key)
        }
    }
}