面试手撕--用C++实现LRU缓存。

下面我将用C++实现一个高效的LRU缓存,使用哈希表(unordered_map)和双向链表(list)的组合来实现O(1)时间复杂度的操作。

完整实现代码

#include <iostream>
#include <list>
#include <unordered_map>

using namespace std;

template <typename K, typename V>
class LRUCache {
public:
    // 构造函数,初始化缓存容量
    LRUCache(size_t size) : capacity(size) {}
    
    // 获取键对应的值
    V get(K key) {
        auto it = cacheMap.find(key);
        if (it == cacheMap.end()) {
            // 键不存在,根据实际需求可以返回默认值或抛出异常
            // 这里返回V类型的默认构造值
            return V();
        }
        
        // 将访问的键值对移到链表头部
        cacheList.splice(cacheList.begin(), cacheList, it->second);
        return it->second->second;
    }
    
    // 插入或更新键值对
    void put(K key, V value) {
        auto it = cacheMap.find(key);
        if (it != cacheMap.end()) {
            // 键已存在,更新值并移到链表头部
            it->second->second = value;
            cacheList.splice(cacheList.begin(), cacheList, it->second);
            return;
        }
        
        // 检查是否达到容量限制
        if (cacheMap.size() == capacity) {
            // 删除链表尾部的元素(最久未使用)
            auto last = cacheList.back();
            cacheMap.erase(last.first);
            cacheList.pop_back();
        }
        
        // 插入新元素到链表头部
        cacheList.emplace_front(key, value);
        cacheMap[key] = cacheList.begin();
    }
    
    // 打印缓存内容(用于调试)
    void printCache() {
        cout << "LRU Cache (capacity=" << capacity << ", size=" << cacheMap.size() << "):" << endl;
        for (const auto& item : cacheList) {
            cout << item.first << ":" << item.second << " ";
        }
        cout << endl;
    }
    
 private:
    // 缓存容量
    size_t capacity;
    
    // 双向链表存储键值对,最近使用的在链表头,最久未使用的在链表尾
    list<pair<K, V>> cacheList;
    
    // 哈希表存储键到链表迭代器的映射
    unordered_map<K, typename list<pair<K, V>>::iterator> cacheMap;

};

// 测试用例
int main() {
    LRUCache<int, string> cache(3);
    
    cache.put(1, "One");
    cache.put(2, "Two");
    cache.put(3, "Three");
    cache.printCache();  // 输出: 3:Three 2:Two 1:One
    
    cout << "Get 2: " << cache.get(2) << endl;  // 输出: Two
    cache.printCache();  // 输出: 2:Two 3:Three 1:One
    
    cache.put(4, "Four");  // 淘汰1:One
    cache.printCache();  // 输出: 4:Four 2:Two 3:Three
    
    cout << "Get 1: " << cache.get(1) << endl;  // 输出空字符串(默认构造值)
    
    return 0;
}

实现说明

  1. 数据结构选择

    • list<pair<K, V>>:双向链表,维护键值对的访问顺序
    • unordered_map<K, list>:哈希表,实现O(1)的键查找
  2. 关键操作

    • get(key):查找键,若存在则将其移到链表头部
    • put(key, value):更新或插入键值对,必要时淘汰最久未使用的项
  3. 性能分析

    • 时间复杂度:get和put操作都是O(1)
    • 空间复杂度:O(capacity)
  4. 线程安全

    • 此实现不是线程安全的,多线程环境下需要加锁

扩展功能

如果需要更完整的实现,可以考虑添加以下功能:

// 添加元素数量查询
size_t size() const {
    return cacheMap.size();
}

// 判断是否包含键
bool contains(K key) const {
    return cacheMap.find(key) != cacheMap.end();
}

// 删除指定键
void erase(K key) {
    auto it = cacheMap.find(key);
    if (it != cacheMap.end()) {
        cacheList.erase(it->second);
        cacheMap.erase(it);
    }
}

// 清空缓存
void clear() {
    cacheList.clear();
    cacheMap.clear();
}
### C++ 实现 LRU 缓存算法 LRU(Least Recently Used,最近最少使用)是一种常见的缓存淘汰策略。当缓存满时,会优先移除最长时间未被访问的数据项。为了高效实现该算法,在C++中可以结合 `std::unordered_map` 和 `std::list` 来构建哈希链表。 以下是完整的 C++ 实现: #### 数据结构设计 1. **双向链表 (`std::list`)** - 存储键值对 `(key, value)`。 - 链表头部表示最近使用的节点,尾部表示最久未使用的节点。 2. **哈希表 (`std::unordered_map`)** - 键为缓存的 key,值为指向链表节点的迭代器。 - 提供 O(1) 时间复杂度的查找能力。 #### 关键方法说明 - **get(key)**: 如果存在指定 key,则将其移到链表头并返回对应的值;否则返回 `-1` 表示不存在。 - **put(key, value)**: 插入或更新指定 key 的值,并调整其位置到链表头。如果超出容量限制,则删除链表尾部的节点。 #### 完整代码实现 ```cpp #include <iostream> #include <unordered_map> #include <list> using namespace std; class LRUCache { private: int capacity; // 缓存的最大容量 list<pair<int, int>> cacheList; // 双向链表存储 (key, value) unordered_map<int, list<pair<int, int>>::iterator> cacheMap; // 哈希表映射 key 到链表迭代器 public: LRUCache(int cap) : capacity(cap) {} int get(int key) { if (cacheMap.find(key) == cacheMap.end()) { // 若找不到对应 key return -1; } // 将找到的节点移动到链表头部 moveToFront(key); return cacheMap[key]->second; // 返回对应的 value } void put(int key, int value) { if (capacity <= 0) return; // 容量非法情况处理 if (cacheMap.find(key) != cacheMap.end()) { // 更新已存在的 key cacheMap[key]->second = value; moveToFront(key); // 调整至链表头部 return; } if (cacheList.size() >= capacity) { // 达到最大容量时移除最旧节点 removeLastRecentlyUsed(); } // 添加新节点到链表头部 cacheList.emplace_front(make_pair(key, value)); cacheMap[key] = cacheList.begin(); // 更新哈希表 } private: void moveToFront(int key) { auto it = cacheMap[key]; // 获取当前节点的位置 pair<int, int> node = *it; // 复制节点 cacheList.erase(it); // 删除原节点 cacheList.push_front(node); // 移动到链表头部 cacheMap[key] = cacheList.begin(); // 更新哈希表中的指针 } void removeLastRecentlyUsed() { int lastKey = cacheList.back().first; // 获取最后一个节点的 key cacheList.pop_back(); // 移除链表尾部节点 cacheMap.erase(lastKey); // 同步移除哈希表中的记录 } }; int main() { LRUCache lruCache(2); // 创建一个容量为 2 的 LRU 缓存 lruCache.put(1, 1); // 缓存 [(1,1)] lruCache.put(2, 2); // 缓存 [(2,2), (1,1)] (最新 -> 最旧) cout << lruCache.get(1) << endl; // 输出 1 并将 (1,1) 移到头部 lruCache.put(3, 3); // 缓存超载,移除最旧的 (2,2),新增 (3,3) cout << lruCache.get(2) << endl; // 输出 -1,因为 (2,2) 已被淘汰 lruCache.put(4, 4); // 新增 (4,4),再次触发淘汰机制,移除 (1,1) cout << lruCache.get(1) << endl; // 输出 -1,因为 (1,1) 已被淘汰 cout << lruCache.get(3) << endl; // 输出 3 cout << lruCache.get(4) << endl; // 输出 4 return 0; } ``` 上述代码实现了基本的 LRU 功能[^1][^2][^3][^4],通过组合 `std::unordered_map` 和 `std::list` 构建了一个高效的缓存系统。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值