LRU算法学习笔记：实现以及应用

最新推荐文章于 2023-07-12 13:18:42 发布

zsiming

最新推荐文章于 2023-07-12 13:18:42 发布

阅读量594

点赞数 1

分类专栏：数据结构 C++秋招学习随笔文章标签：算法学习链表

本文链接：https://blog.csdn.net/zsiming/article/details/126749276

版权

C++秋招学习随笔同时被 2 个专栏收录

29 篇文章 4 订阅

订阅专栏

数据结构

9 篇文章 0 订阅

订阅专栏

文章目录

一、LRU算法的实现
二、LRU算法的实现（C++）

一、LRU算法的实现

其实很久以前就已经学过了LRU算法，在秋招面试之余整理成文章，以便面试的时候说得条理清晰一点。

所谓LRU（Least Recently Used）就是最近最少使用算法。其核心的思想就是根据每个节点的最后一次访问事件来对每个结点进行排序。最近一次使用的排在队头，依次类推。

如果实现这样的一个链表，一般需要实现两个功能：

快速插入元素（这个元素包含key，value两个部分）
快速访问元素（根据key快速拿到value）

此外，这个链表随着不断的插入新的元素，肯定不断变长。因此对于这个链表来说，需要一个容量上限。超过了这个容量的上限，那么就需要把链表尾部（距离现在最久一次访问的结点）进行删除。

所以，实现这个链表，还隐藏了第三个功能：

快速删除元素

因此：

从快速删除、插入的角度来看的话，需要一个链表来维护结点的时序关系。
从快速根据元素的key来拿到value来看的话，需要一个哈希表来维护key和value的关系。

根据这种思路，我们可以很快的想到：

维护一个链表，链表中的结点放value，然后维护一个哈希表，可以根据key快速的拿到结点，然后取出里面的key。

实际上，还需要考虑一些其他的细节：

链表是单向还是双向？
结点这样设计真的可以吗？

回答：

链表需要双向。我们思考什么时候会删除一个元素：
1. 链表满了，我们需要删除尾部的结点。
2. 访问了链表中间的结点，需要把这个结点删除，然后插到链表头。

在上面的这两种情况下，删除一个结点cur需要将这个结点的前一个结点的next指针指向cur的下一个结点。因此，需要知道cur的前一个结点是谁。

结点需要同时维护key和value，不能只有value。 假设现在因为插入一个结点到链表里面，导致链表满了，需要删除尾部的结点。那么尾部结点是很容易删除，但是哈希表中维护了这个结点的信息也要被删除。结点里面只有value，怎么知道哈希表里面删除谁呢？

有了这些思考，我们就可以实现一个LRU结构了。

二、LRU算法的实现（C++）

根据上面的分析，我们实现的LRU数据结构图如下：

在这里插入图片描述

unordered_map用于快速根据key找到结点
链表中的结点包括四个变量：

1. prev_：指向上一个结点
2. next_：指向下一个结点
3. key_：关键字
4. value_：存储元素

下面是具体实现：

class LRUCache {
private:
    struct Node {
        Node(int key = -1, int val = 0, Node* prev = nullptr, Node* next = nullptr) : key_(key), val_(val), prev_(prev), next_(next) {} 
        Node* prev_;
        Node* next_;
        int key_;
        int val_;
    };

public:
    LRUCache(int capacity) : cap_(capacity), size_(0) {
        head_ = new Node();
        tail_ = new Node();
        
        head_->next_ = tail_;
        tail_->prev_ = head_;
    }
    
    int get(int key) {
        auto it = key2Node_.find(key);
        if (it == key2Node_.end()) return -1;

        Node* node = it->second;
        int res = node->val_;

        //1. 从链表中拆下这个节点
        deleteNode(node);
        //2. 添加到链表头
        addToHead(node);

        return res;
    }

    void deleteNode(Node* node) {
        node->prev_->next_ = node->next_;
        node->next_->prev_ = node->prev_;
    }

    void addToHead(Node* node) {
        node->next_ = head_->next_;
        head_->next_->prev_ = node;

        node->prev_ = head_;
        head_->next_ = node;
    }
    
    void put(int key, int value) {
        auto it = key2Node_.find(key);
        if (it == key2Node_.end()) {
            // 1. 创建节点
            Node* addNode = new Node(key, value);
            key2Node_[key] = addNode;
            // 2. 插到队头
            addToHead(addNode);
            // 3. 判断是否溢出
            ++size_;
            if (size_ > cap_) {
                key2Node_.erase(tail_->prev_->key_);
                deleteNode(tail_->prev_);
                --size_;
            }
        } else {
            // 1. 更改节点的值
            Node* node = it->second;
            node->val_ = value;
            // 2. 删除节点
            deleteNode(node);
            // 3. 插到队头
            addToHead(node);
        }
    }

private:

    unordered_map<int, Node*> key2Node_;
    Node* head_ = nullptr;
    Node* tail_ = nullptr;

    int size_ = 0;
    int cap_ = 0;
};

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