leetcode-LRU缓存机制

题目

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

获取数据 get(key) - 如果关键字 (key) 存在于缓存中，则获取关键字的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字/值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

示例:

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 该操作会使得关键字 2 作废
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 该操作会使得关键字 1 作废
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

解题思路

题目非常直接，思路很清晰，就是维护一个数据结构，使其满足LRU的条件。

在每次get、put时，需要更新key的优先级，所有需要一个存储数据的有序数据结构。

由于需要维护一定长度，所以需要维护该数据结构一个常量，用来表示该数据结构的长度。

最后使用了数组去存储对应的key-value，使用一个常量限制数组的长度，在构造该数据结构时便赋值。

在get时，先获取对应key的位置，返回该value，并且把该项删除再增加到数组头（提升其优先级）。

在put时，如果已有key，则更新value和把该项删除再增加到数组头，如果没有则判断其长度是否达上限，如果是则进行unshift和pop操作。

解题代码如下

class LRUCache {
    constructor(capacity) {
        this.arr = [];
        this.arrLength = capacity;
    }

    get(key) {
        const index = this.arr.findIndex(
            item => item.key === key
        )
        if (index > -1) {
            // 更新该键对应的项的优先级
            this.arr.unshift(this.arr.splice(index,1)[0]);
            return this.arr[0].value;
        }
        return -1;
    };

    put(key, value) {
        const index = this.arr.findIndex(item => item.key === key)
        if (index > -1) {
            this.arr[index].value = value;
            // 更新该键对应的项的优先级
            this.arr.unshift(this.arr.splice(index,1)[0]);
            return;
        }
        if (this.arr.length === this.arrLength) {
            // 删除最后一个项
            this.arr.pop();
        }
        // 增加项
        this.arr.unshift({key, value});
    };
}

改进

Map对象在迭代时会根据对象中元素的插入顺序来进行一个forof循环在每次迭代后会返回一个形式为[key，value]的数组。map是有序的。

可以使用map来作为该数据结构，由于map在频繁增删键值对的场景下性能更好。使用map改进之后，花费时间较少一半，消耗空间不变。

代码如下：

class LRUCache {
    constructor(capacity) {
        this.cache = new Map();
        this.capacity = capacity
    }

    get(key) {
        if (this.cache.has(key)) {
            let temp = this.cache.get(key)
            // 删除原有的键再增加，使其优先级变高
            this.cache.delete(key)
            this.cache.set(key, temp)
            return temp
        }
        return -1
    };

    put(key, value) {
        if (this.cache.has(key)) {
            // 删除原有的键再增加，使其优先级变高
            this.cache.delete(key)
        } else if (this.cache.size >= this.capacity) {
            // 删除第一个项，即优先级最低的项
            this.cache.delete(this.cache.keys().next().value)
        }
        this.cache.set(key, value)
    };
}