LRU算法

2022-06-21 18:00:35 阅读：99 来源： 互联网

标签：int QuickAccess pRoot next QANode 算法 LRU key

 1 //QuickAccess.h
 2 
 3 #pragma once
 4 
 5 #include <map>
 6 
 7 struct QANode
 8 {
 9     QANode(int _key, int _value)
10         : key(_key)
11         , value(_value)
12         , next(nullptr)
13         , prev(nullptr) 
14     {}
15     QANode* next;
16     QANode* prev;
17     int key;
18     int value;
19 };
20 
21 class QuickAccess
22 {
23 public:
24     QuickAccess();
25 
26     QuickAccess(int size);
27 
28     ~QuickAccess();
29 
30     int Access(int id);
31 
32     double GetHitRate();
33 
34     void PrintItems();
35 
36 private:
37     void MoveToHead(QANode* hitNode);
38 
39     void InsertNode(QANode* newNode);
40 
41     int Search(int id);
42 
43 private:
44     int m_nCapacity;
45     int m_nSize = 0;
46     std::map<int, void*> m_map;
47     QANode* m_pRoot;
48 
49     int m_nAccessCount = 0;
50     int m_nHitCount = 0;
51 };

  1 //QuickAccess.cpp
  2 
  3 #include "QuickAccess.h"
  4 #include <cstdlib>
  5 #include <ctime>
  6 
  7 QuickAccess::QuickAccess()
  8     : m_nCapacity(10)
  9 {
 10     QuickAccess(m_nCapacity);
 11 }
 12 
 13 QuickAccess::QuickAccess(int nCapacity)
 14     : m_nCapacity(nCapacity)
 15 {
 16     srand(time(0));
 17     m_pRoot = new QANode(0, 0);
 18     m_pRoot->prev = m_pRoot;
 19     m_pRoot->next = m_pRoot;
 20 }
 21 
 22 QuickAccess::~QuickAccess()
 23 {
 24     QANode* currentNode = m_pRoot->next;
 25     QANode* deleteNode = currentNode;
 26     while (currentNode != m_pRoot) {
 27         currentNode = currentNode->next;
 28         delete deleteNode;
 29         deleteNode = currentNode;
 30     }
 31     delete m_pRoot;
 32     m_pRoot = nullptr;
 33 }
 34 
 35 int QuickAccess::Access(int key)
 36 {
 37     m_nAccessCount++;
 38     auto it = m_map.find(key);
 39     if (it == m_map.end()) {//未命中
 40         int value = Search(key);
 41         InsertNode(new QANode(key, value));
 42     }
 43     else {//命中
 44         m_nHitCount++;
 45         MoveToHead((QANode*)m_map[key]);
 46     }
 47     return ((QANode*)m_map[key])->value;
 48 }
 49 
 50 //1,2,3,4,5
 51 void QuickAccess::MoveToHead(QANode* hitNode)
 52 {
 53     hitNode->prev->next = hitNode->next;
 54     hitNode->next->prev = hitNode->prev;
 55 
 56     hitNode->next = m_pRoot->next;
 57     m_pRoot->next->prev = hitNode;
 58 
 59     hitNode->prev = m_pRoot;
 60     m_pRoot->next = hitNode;
 61 }
 62 
 63 void QuickAccess::InsertNode(QANode* newNode)
 64 {
 65     //insert new item to head
 66     newNode->next = m_pRoot->next;
 67     m_pRoot->next->prev = newNode;
 68     m_pRoot->next = newNode;
 69     newNode->prev = m_pRoot;
 70     m_map[newNode->key] = newNode;
 71     if (m_nSize == m_nCapacity) {//full
 72         //delete last item
 73         QANode* lastSecondItem = m_pRoot->prev->prev;
 74         m_map.erase(lastSecondItem->next->key);
 75         delete lastSecondItem->next;
 76         lastSecondItem->next = m_pRoot;
 77         m_pRoot->prev = lastSecondItem;
 78     }
 79     else {
 80         m_nSize++;
 81     }
 82 }
 83 
 84 int QuickAccess::Search(int id)
 85 {
 86     int reverse = 0;
 87     while (id) {
 88         reverse = (reverse * 10) + (id % 10);
 89         id /= 10;
 90     }
 91     return reverse;
 92 }
 93 
 94 double QuickAccess::GetHitRate()
 95 {
 96     return (m_nHitCount * 1.0) / m_nAccessCount;
 97 }
 98 
 99 void QuickAccess::PrintItems()
100 {
101     QANode* currentNode = m_pRoot->next;
102     int alignCnt = 1;
103     printf("\n******************************PrintItems*************************************\n");
104     while (currentNode != m_pRoot) {
105         printf("%d[%d]   ", currentNode->key, currentNode->value);
106         if (alignCnt % 10 == 0) {
107             printf("\n");
108             alignCnt = 0;
109         }
110         alignCnt++;
111         currentNode = currentNode->next;
112     }
113     printf("\n");
114 }

// 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");
}

标签：int,QuickAccess,pRoot,next,QANode,算法,LRU,key
来源： https://www.cnblogs.com/endenvor/p/16397759.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

LRU算法