LRU （近期最少使用）算法 c++实现

前言

这两天碰到面试题，说是页面调度算法，之前在操作系统书上有了解过，LRU（近期最少使用），还有OPT（最佳页面替换算法）、FIFO（先进先出页面置换算法），今天先来实现LRU 最近最少使用。

LRU 原理

LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。

参照网上的写法，给出以下例子做个参考：

#include <iostream>
#include <unordered_map>  
#include <list>  
#include <utility>  
using namespace std;
using namespace stdext;

class LRUCache {
public:
    LRUCache(int capacity) {
        m_capacity = capacity;
    }

    int get(int key) {
        int retValue = -1;
        unordered_map<int, list<pair<int, int> > ::iterator> ::iterator it = cachesMap.find(key);

        //如果在Cashe中，将记录移动到链表的最前端  
        if (it != cachesMap.end())
        {
            retValue = it->second->second;
            //移动到最前端  
            list<pair<int, int> > ::iterator ptrPair = it->second;
            pair<int, int> tmpPair = *ptrPair;
            caches.erase(ptrPair++);
            caches.push_front(tmpPair);


            //修改map中的值  
            cachesMap[key] = caches.begin();
        }
        return retValue;
    }

    void set(int key, int value) {

        unordered_map<int, list<pair<int, int> > ::iterator> ::iterator it = cachesMap.find(key);

        if (it != cachesMap.end()) //已经存在其中  
        {
            list<pair<int, int> > ::iterator ptrPait = it->second;
            ptrPait->second = value;
            //移动到最前面  
            pair<int, int > tmpPair = *ptrPait;
            caches.erase(ptrPait);
            caches.push_front(tmpPair);


            //更新map  
            cachesMap[key] = caches.begin();
        }
        else //不存在其中  
        {
            pair<int, int > tmpPair = make_pair(key, value);


            if (m_capacity == caches.size()) //已经满  
            {
                int delKey = caches.back().first;
                caches.pop_back(); //删除最后一个  


                                   //删除在map中的相应项  
                unordered_map<int, list<pair<int, int> > ::iterator> ::iterator delIt = cachesMap.find(delKey);
                cachesMap.erase(delIt++);
            }


            caches.push_front(tmpPair);
            cachesMap[key] = caches.begin(); //更新map  
        }
    }


private:
    int m_capacity;                                                                        //cashe的大小  
    list<pair<int, int> > caches;                                                  //用一个双链表存储cashe的内容  
    unordered_map< int, list<pair<int, int> > ::iterator> cachesMap;         //使用map加快查找的速度  
};


int main(int argc, char **argv)
{
    LRUCache s(2);
    s.set(2, 1);
    s.set(1, 1);
    cout << s.get(2) << endl;
    s.set(4, 1);
    s.set(5, 2);
    cout << s.get(5) << endl;
    cout << s.get(4) << endl;
    getchar();
    return 0;
}

在vs 2015 进行运行 ，输出：

解释：程序首先会初始化2个存储空间的LRUCache类，依次插进{2, 1 }，{1，1} ，之后输出 key=2 => value=1 ，之后插进 {4, 1} ， 因为已经满了所以替换掉最近没有使用的{1 ，1} ，变成了 { 4,1} ，{2，1} ，之后又插进{5, 2} ，又替换掉了 {2，1} ，变成了 {4, 1} ，{5，2}，然后输出剩下两个key，再重新排序谁最近使用过。

用到的知识是 ： 双链表 + 哈希表 （使用map，内部元素自动排序；使用unordered_map内部不会进行有序排序）

页面调度算法（LRU）的原理 ：缓存机制中新数据或击中的数据放到链表头部，表示最近使用的数据，如果链表满，从尾部淘汰数据。但只用链表会存在一个问题，击中数据的时间复杂度为O(n)，每次需要遍历链表，所以引入哈希表，时间复杂度降到O(1)，以空间换时间。