【leetcode热题Hot100】——LRU缓存

• 💂 个人主页:努力学习的少年
• 🤟 版权: 本文由【努力学习的少年】原创、在CSDN首发、需要转载请联系博主
• 💬 如果文章对你有帮助、欢迎关注、点赞、收藏(一键三连)和订阅专栏哦

目录

一. 题目

1.题目描述

2.基础框架

3.原题链接

二.解题报告

代码详解

---

一. 题目

1.题目描述

请你设计并实现一个满足  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]

2.基础框架

​

class LRUCache {
public:
    LRUCache(int capacity) {

    }
    
    int get(int key) {

    }
    
    void put(int key, int value) {

    }
};


​

3.原题链接

LRU缓存

二.解题报告

思路：

该结构我们将设置为 双向链表+哈希表 的结构。

哈希表存储的 key-节点的地址，方便找到对应的节点。

双向链表中的节点存储的是 key-value 的值，该双向链表包含了 head节点 和 tail节点，head节点指向的是最近被使用过的节点（新插入，修改，返回值），tail节点指向的是最久未使用的节点。

void put(int key，int value)实现;

• 如果key值在哈希表中找不到，则说明该key值的节点不存在,因此 我们需要将key值节点插入到head的后面。

如下：新插入4-4的节点，通过哈希表发现，该key值不存在，说明key=4的节点不存在。

• 如果key值在哈希表总找到了，则说明该key值的节点存在，因此我们去修改节点的value，并将修改的节点链接到后面，代表该节点最近被使用过。

如下：put(3,4);因为key=3节点已经存在，所以我们需要该节点的value进行修改。

首先通过哈希表找到该节点，修改后再将该节点放在head的后面，表示该节点最近被使用过。

 

• 如果插入的节点的数量大于capacity，我们需要删除链表最后一个节点，也就是tail节点前面的节点，在将新节点插入到head节点的后面。

假设LRU的capacity为3，那么如果我们在插入一个key-value值为4,4，我们需要删除tail最后一个节点，因为它是最久没有被使用过的节点，然后将删除的节点在哈希表的映射关系。再将key=4的节点插入到head后面，如下

int get(value)函数

• 如果key值在哈希表中找不到，直接返回-1。
• 如果找到了，那么找到相对应的节点，并将该节点连接到head的后面，代表该节点最近是被使用过，然后再返回它的value值。

如下：查找key的值为2；

 我们将1节点和3节点互相连接，然后再将head与2节点互相连接，连接的时间复杂度为O(1).

总结：由于key-节点的地址存储在哈希表中，因此查找节点的时间复杂度是O(1),节点连接的过程也是O(1),删除节点是直接将tail前面的节点删除，因此时间复杂度也为O(1),因此，整个get()和put（）的时间复杂度都是O(1).

代码详解

//设置Node节点类
class Node{
 public:
    int _key;
    int _value;
    Node* prev=nullptr;
    Node* next=nullptr;
public:
    Node(int key=0,int value=0):_key(key),_value(value){}
};
class LRUCache {
public:
    LRUCache(int capacity) {
        _capacity=capacity;
        head=new Node();
        tail=new Node();
        head->next=tail;
        tail->prev=head;
    }
    
    int get(int key) {
        //该key值没有在LRU缓存中
        if(mp.count(key)==0){
            return -1;
        }
        //该key值在LRU缓存中
        //找到该节点，连接前后节点
            Node* cur=mp[key]; 
            if(head->next==cur)
            return cur->_value;

            Node* next=cur->next;
            Node* prev=cur->prev;
            Node* headNext=head->next;


            next->prev=prev;
            prev->next=next;

            //将该节点与head互相连接
            head->next=cur;
            cur->prev=head;
             
            cur->next=headNext;
            headNext->prev=cur;
            return cur->_value;
        
    }
    
    void put(int key, int value) {
        if(mp.count(key)){
            //该节点存在，修改节点的value值
            Node* cur=mp[key];

            cur->_value=value;
            if(head->next==cur)
            return;
            Node* prev=cur->prev;
            Node* next=cur->next;
            Node* headNext=head->next;

            prev->next=next;
            next->prev=prev;

            head->next=cur;
            cur->prev=head;

            cur->next=headNext;
            headNext->prev=cur;
            return;
        }else{
            //不存在         
            if(size==_capacity){
                //如果LRU缓存满了，删除最后一个节点
                Node* prev=tail->prev;
                Node* pprev=prev->prev;
                pprev->next=tail;

                tail->prev=pprev;
                mp.erase(prev->_key);
                delete prev;
                prev=nullptr;
                size--;
            }
            //创建新的节点，并将它连接在head的后面
            Node* cur=new Node(key,value);
            mp[key]=cur;

            Node* headNext=head->next;
            cur->prev=head;
            head->next=cur;

            cur->next=headNext;
            headNext->prev=cur;
            size++;
        }
    }
private:
    Node* head;//双向链表的头节点
    Node* tail;//双向链表的末尾节点
    unordered_map<int,Node*> mp;//哈希表
    int _capacity;//LRU的容量
    int size=0;//LRU中存在节点的个数
};