LRU算法

//QuickAccess.h

#pragma once

#include <map>

struct QANode
{
    QANode(int _key, int _value)
        : key(_key)
        , value(_value)
        , next(nullptr)
        , prev(nullptr) 
    {}
    QANode* next;
    QANode* prev;
    int key;
    int value;
};

class QuickAccess
{
public:
    QuickAccess();

    QuickAccess(int size);

    ~QuickAccess();

    int Access(int id);

    double GetHitRate();

    void PrintItems();

private:
    void MoveToHead(QANode* hitNode);

    void InsertNode(QANode* newNode);

    int Search(int id);

private:
    int m_nCapacity;
    int m_nSize = 0;
    std::map<int, void*> m_map;
    QANode* m_pRoot;

    int m_nAccessCount = 0;
    int m_nHitCount = 0;
};

//QuickAccess.cpp

#include "QuickAccess.h"
#include <cstdlib>
#include <ctime>

QuickAccess::QuickAccess()
    : m_nCapacity(10)
{
    QuickAccess(m_nCapacity);
}

QuickAccess::QuickAccess(int nCapacity)
    : m_nCapacity(nCapacity)
{
    srand(time(0));
    m_pRoot = new QANode(0, 0);
    m_pRoot->prev = m_pRoot;
    m_pRoot->next = m_pRoot;
}

QuickAccess::~QuickAccess()
{
    QANode* currentNode = m_pRoot->next;
    QANode* deleteNode = currentNode;
    while (currentNode != m_pRoot) {
        currentNode = currentNode->next;
        delete deleteNode;
        deleteNode = currentNode;
    }
    delete m_pRoot;
    m_pRoot = nullptr;
}

int QuickAccess::Access(int key)
{
    m_nAccessCount++;
    auto it = m_map.find(key);
    if (it == m_map.end()) {//未命中
        int value = Search(key);
        InsertNode(new QANode(key, value));
    }
    else {//命中
        m_nHitCount++;
        MoveToHead((QANode*)m_map[key]);
    }
    return ((QANode*)m_map[key])->value;
}

//1,2,3,4,5
void QuickAccess::MoveToHead(QANode* hitNode)
{
    hitNode->prev->next = hitNode->next;
    hitNode->next->prev = hitNode->prev;

    hitNode->next = m_pRoot->next;
    m_pRoot->next->prev = hitNode;

    hitNode->prev = m_pRoot;
    m_pRoot->next = hitNode;
}

void QuickAccess::InsertNode(QANode* newNode)
{
    //insert new item to head
    newNode->next = m_pRoot->next;
    m_pRoot->next->prev = newNode;
    m_pRoot->next = newNode;
    newNode->prev = m_pRoot;
    m_map[newNode->key] = newNode;
    if (m_nSize == m_nCapacity) {//full
        //delete last item
        QANode* lastSecondItem = m_pRoot->prev->prev;
        m_map.erase(lastSecondItem->next->key);
        delete lastSecondItem->next;
        lastSecondItem->next = m_pRoot;
        m_pRoot->prev = lastSecondItem;
    }
    else {
        m_nSize++;
    }
}

int QuickAccess::Search(int id)
{
    int reverse = 0;
    while (id) {
        reverse = (reverse * 10) + (id % 10);
        id /= 10;
    }
    return reverse;
}

double QuickAccess::GetHitRate()
{
    return (m_nHitCount * 1.0) / m_nAccessCount;
}

void QuickAccess::PrintItems()
{
    QANode* currentNode = m_pRoot->next;
    int alignCnt = 1;
    printf("\n******************************PrintItems*************************************\n");
    while (currentNode != m_pRoot) {
        printf("%d[%d]   ", currentNode->key, currentNode->value);
        if (alignCnt % 10 == 0) {
            printf("\n");
            alignCnt = 0;
        }
        alignCnt++;
        currentNode = currentNode->next;
    }
    printf("\n");
}

// ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <random>
#include "QuickAccess.h"

void QuickAccessTest();

int main()
{
    QuickAccessTest();
    return 0;
}

void QuickAccessTest()
{
    srand(time(0));
    int cacheSize = 0;
    int searchRange = 0;
    while (1) {
        printf("input cache size and search range: ");
        if (scanf_s("%d,%d", &cacheSize, &searchRange) != 2) {
            return;
        }
        QuickAccess qa(cacheSize);
        for (int i = 0; i < 100000; i++) {
            int randValue = rand() % searchRange;
            qa.Access(randValue);
        }
        qa.PrintItems();
        printf("\nhitRate = %lf\n", qa.GetHitRate());
    }
    printf("\n\n");
}