单链表实现LRU缓存淘汰算法

程序员班长

于 2024-03-13 23:32:14 发布

阅读量457

点赞数 7

分类专栏： C++ 文章标签：缓存算法 LRU

本文链接：https://blog.csdn.net/KK_2018/article/details/136692383

版权

C++ 专栏收录该内容

9 篇文章

订阅专栏

本文介绍了如何使用单链表数据结构实现LRU缓存淘汰算法，通过模拟内存缓存的动态管理，处理数据未在缓存、缓存空间充足和已满三种情况。

摘要由CSDN通过智能技术生成

单链表实现LRU缓存淘汰算法

什么是LRU缓存淘汰算法

因为计算机内存中的缓存大小是有限的，所以当缓存满的时候，我们必须采用某种算法来替换掉某块缓存。常用的算法有FIFO（先进先出）、LFU（最少使用）、LRU（最近最少使用）。

LRU（Least Recently Used）算法也叫做最近最少使用算法。顾名思义，也就是当内存中的缓存满的时候，有新的数据需要加入到缓存中，最近使用过的缓存很可能还会再次使用到，所以我们需要将最近时间内使用次数最少的缓存替换掉。

思路

设计一个单链表，用来表示内存中的缓存，链表尾部表示最近最少使用的缓存，当需要访问一块数据时，需要考虑下面的三种情况：

数据已经在缓存中，那么就把这块缓存移动到链表头部；
数据未在缓存中，如果当前缓存还有空间，就把新数据加入到链表头部；
数据未在缓存中，如果当前缓存空间已经用完，就把链表尾部的缓存删除，将新的数据插入到链表头部。

代码实现

#include <iostream>

using namespace std;

typedef int DataType;

// 定义单链表节点
class SingleNode
{
public:
    DataType data;
    SingleNode *next;
};

// 定义单链表
class SingleList
{
public:
    SingleList(int maxSize);
    ~SingleList();
    // 头插法插入数据
    void insertDataHead(DataType value);
    // 查询当前数据是否存在,存在则返回当前数据的前一个节点指针
    SingleNode *searchIsExist(DataType value);
    // 删除最后一个节点
    void deleteLastNode();
    // 打印当前链表
    void printList();

    int listLength; // 链表长度
    int maxSize;    // 链表的最大长度

private:
    SingleNode *Head;   // 头节点
};

// 初始化单链表
SingleList::SingleList(int maxSize)
{
    // 申请头节点
    Head=new SingleNode();
    Head->data=0;
    Head->next=nullptr;
    this->listLength=0;
    this->maxSize=maxSize;
}

// 销毁单链表
SingleList::~SingleList()
{
    SingleNode *p;
    SingleNode *temp;
    p=this->Head;
    while(p->next!=nullptr)
    {
        temp=p->next;
        p->next=temp->next;
        delete temp;
    }
    // 删除头节点
    delete this->Head;
    this->Head=nullptr;
    delete p;
    p=nullptr;
    this->listLength=0;
}

// 头插法插入数据
void SingleList::insertDataHead(DataType value)
{
    SingleNode *p=new SingleNode();
    p->data=value;
    p->next=this->Head->next;
    this->Head->next=p;
    this->listLength++;
}

// 查询当前数据是否存在，存在则返回当前数据的前一个节点指针
SingleNode *SingleList::searchIsExist(DataType value)
{
    SingleNode *p;
    p=this->Head;
    while(p->next!=nullptr)
    {
        if(p->next->data==value)
        {
            return p;
        }
        p=p->next;
    }

    return nullptr;
}

// 删除最后一个节点
void SingleList::deleteLastNode()
{
    SingleNode *p,*temp;
    p=this->Head;
    while(p->next->next!=nullptr)
    {
        p=p->next;
    }
    temp=p->next;
    p->next=nullptr;
    delete temp;
    temp=nullptr;
    this->listLength--;
}

// 打印当前链表
void SingleList::printList()
{
    SingleNode *p=this->Head;
    while(p->next!=nullptr)
    {
        cout<<p->next->data<<" ";
        p=p->next;
    }
    cout<<endl;
}

int main()
{
    // 定义当前的缓存大小
    int maxSize;
    cout<<"输入缓存大小：";
    cin>>maxSize;
    SingleList singleLS(maxSize);
    DataType data;
    // 模拟LRU算法
    while(true)
    {
        cout<<"输入新数据：";
        cin>>data;
        // 查询数据是否已经在缓存中
        SingleNode *p=singleLS.searchIsExist(data);
        if(p)
        {
            SingleNode *temp=p->next;
            p->next=temp->next;
            delete temp;
            temp=nullptr;
            singleLS.listLength--;
            singleLS.insertDataHead(data);
        }
        else
        {
            // 缓存未满则插入到头部
            if(singleLS.listLength<singleLS.maxSize)
            {
                singleLS.insertDataHead(data);
            }
            // 缓存已满则删除最后的数据，并将新数据插入到头部
            else
            {
                singleLS.deleteLastNode();
                singleLS.insertDataHead(data);
            }
        }
        cout<<"输出当前缓存情况："<<endl;
        singleLS.printList();
    }
    return 0;
}