当前位置：首页 > article >正文

【Leetcode 每日一题】146. LRU 缓存（c++）

article 2024/11/26 13:32:37

146. LRU 缓存

请你设计并实现一个满足 LRU (最近最少使用) 缓存约束的数据结构。

实现 LRUCache 类：

LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该逐出最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例：

输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

提示：

1 <= capacity <= 3000
0 <= key <= 10000
0 <= value <= 105
最多调用 2 * 105 次 get 和 put

思考：

// # 键值对--哈希表

// # 出入顺序--栈、队列、链表

// # 随机访问，插入头部或者尾部--双向链表 O（1）

// # 包括插入、移动、删除

使用一个哈希表来存储键和它们对应的值以及在双向链表中的位置，同时使用一个双向链表来维护键的最近使用顺序。在执行get操作时，如果键存在，则将其对应的节点移动到双向链表的末尾，表示最近被访问；在执行put操作时，如果键已存在，则更新其值并移动到链表末尾，如果键不存在，则检查缓存是否已满，若已满则从链表头部移除最久未使用的键，然后添加新键值对到缓存中。这样，通过结合哈希表的快速查找和双向链表的顺序维护，实现了平均时间复杂度为O(1)的LRU缓存机制。

参考代码（c++）：

class LRUCache {
    // # 键值对--哈希表
    // # 出入顺序--栈、队列、链表
    // # 随机访问，插入头部或者尾部--双向链表
    // # 包括插入、移动、删除
private:
    int capacity0; // 缓存的容量
    list<int> keyList; // 用于维护键的顺序，最近使用的在末尾
    unordered_map<int, pair<int, list<int>::iterator>> hashMap; // 哈希表，存储键、值和键在keyList中的迭代器

public:
    LRUCache(int capacity) {
        capacity0 = capacity; // 初始化缓存容量
    }
    
    int get(int key) {
        auto it = hashMap.find(key); // 在哈希表中查找键
        if(it != hashMap.end()){ // 如果找到了键
            keyList.erase(it->second.second); // 从keyList中移除旧的键
            keyList.push_back(key); // 将键重新添加到keyList的末尾，表示最近被访问
            hashMap[key].second = (--keyList.end()); // 更新哈希表中的迭代器，指向新的末尾位置
            return it->second.first; // 返回键对应的值
        }
        return -1; // 如果键不存在，返回-1
    }
    
    void put(int key, int value) {
        if(hashMap.find(key) != hashMap.end()){ // 如果键已经存在
            hashMap[key].first = value; // 更新键对应的值
            keyList.erase(hashMap[key].second); // 从keyList中移除旧的键
            keyList.push_back(key); // 将键重新添加到keyList的末尾
            hashMap[key].second = (--keyList.end()); // 更新哈希表中的迭代器，指向新的末尾位置
            return; // 更新完成后返回
        }
        if(hashMap.size() < capacity0){ // 如果当前缓存大小小于容量
            Insert(key, value); // 调用Insert函数插入新的键值对
        }else{
            int removeKey = keyList.front(); // 获取并移除keyList中的第一个元素（最久未使用的键）
            keyList.pop_front(); // 从keyList中移除第一个元素
            hashMap.erase(removeKey); // 从哈希表中移除对应的键值对

            Insert(key, value); // 插入新的键值对
        }
    }

    // 插入或更新键值对的辅助函数
    void Insert(int key, int value){
        keyList.push_back(key); // 将键添加到keyList的末尾
        hashMap[key] = make_pair(value, --keyList.end()); // 在哈希表中添加键值对和迭代器
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */

查看全文

http://www.kler.cn/a/409999.html