leetcode146. LRU 缓存(C++|数据结构|双链表|哈希表)

力扣

题目描述

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

果果念

今天早早地回来了，大概十点三十到家了。然后洗漱之后看了一会短视频就到十二点了，真是白驹过隙呀，明天可以线上课了。今天做了7道题目，还是蛮不错的，希望可以有个好结果吧。

回到这道题目，之前听过面试考察LRU，感觉还挺频繁的，今天被同学安利了一个新网站，codetop，确实挺好用的，不过这个的前提是要有一些基础。这道题目可以归于一个数据结构的设计题目，一开始自己只想到了map，但是map里还要存储非基本数据类型数据，然后有点不知所措，看完题解之后，用到了双链表+哈希表，简称，哈希链表。

其中双指针用来删除、插入时候的O(1)复杂度；哈希表用来保证查找时候的O(1)复杂度，组合起来 还蛮巧妙地。对了，Java好像有自带的linkedhashmap，底层基于数组+链表+红黑树，我还没有深入研究过，这道题目也没用Java写。

这里还在类里新建了一个结构体Node。

下面是我参考的一个题解，感觉解释的挺清晰的。

 

作者：lin-shen-shi-jian-lu-k
链接：https://leetcode-cn.com/problems/lru-cache/solution/146-lru-huan-cun-ji-zhi-cxiang-xi-ti-jie-ulv8/

代码

class LRUCache {
public:
//注意两点：
//1.插入删除时间复杂度为O(1),只能使用链表实现
//2.查找的时间复杂度为O(1)，使用hash表来解决
//综上所述，使用哈希链表

    struct Node{
        Node *pre,*next;//单向链表
        int key,value;
        Node(int key_,int value_){
            key=key_;
            value=value_;
        }
    }*L,*R;//最左最右节点

    //插入的话就在链表头部插入
    void insert(Node *p){
        p->pre=L;
        p->next=L->next;
        L->next->pre=p;
        L->next=p;
    }
    
    //移除元素的话需要注意
    void remove(Node *p){
        p->pre->next=p->next;
        p->next->pre=p->pre;
    }

    int n;//容量
    unordered_map<int,Node*> map;
    LRUCache(int capacity) {
        n=capacity;
        L = new Node(-1,-1);//头元素
        R = new Node(-1,-1);//尾部元素
        L->next=R;
        R->pre=L;

    }
    
    int get(int key) {
        if(map.count(key)==0)
            return -1;
        else {
            //存在这个元素
            Node *p=map[key];
            remove(p);
            insert(p);
            return p->value;
        }
    }
    
    void put(int key, int value) {
        if(map.count(key)==1){
            //存在，更新
            Node *p=map[key];
            p->value=value;
            remove(p);
            insert(p);
        }
        else{
            if(map.size()==n){
            //满了
                Node *p=R->pre;
                remove(p);
                map.erase(p->key);
            }
            Node *p=new Node(key,value);
            map[key]=p;
            insert(p);
        }
    }
};

/**
 * 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);
 */