LeetCode：146_LRU cache | LRU缓存设计

LeetCode：146_LRU cache | LRU缓存设计 | Hard

本文转载自查看原文 2014-10-10 16:54 2762 LeetCode

题目：LRU cache

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

LRU是一种应用在操作系统上的缓存替换策略，和我们常见的FIFO算法一样，都是用于操作系统中内存管理中的页面替换，其全称叫做Least Recently Used（近期最少使用算法），算法主要是根据数据的历史访问记录来进行数据的淘汰，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。

LRU算法设计

数据结构的选择：因为涉及到数据元素的查找，删除，替换，移动等操作，所以我们选择列表来进行数据的存储，为了考虑时间复杂度，我们分析一下，单链表插入删除操作的时间复杂度为O(n)，双链表为O(1)，所以，首选肯定是双链表，另外，元素的查找操作，map的查找效率为O(lgn)，首选应该是map，但还有一个hashmap，能够达到O(1)的查找效率，我们后面再编程的时候都试一下这几种方法，看看其能不能通过编译，通过了时间又是多少？

为了能够比较形象的了解LRU的执行过程，我们举一个例子，如下：

假定现有一进程的页面访问序列为：

4，7，0，7，1，0，1，2，1，2，6

缓存容量为5，则随着进程的访问，缓存栈中页面号的变化情况如下图所示。在访问页面6时发生了缺页，此时页面4是最近最久未被访问的页，应将它置换出去。

在算法实现时，我们可以把最近最久没有使用的数据放在链表的最后，当缓存空间满时（即发生缺页），直接将最后一个数据淘汰即可，同时，如果一个数据发生命中，或者新来一个数据，我们都将该数据移到链表的头部，这样就能保证在链表头部的数据都是最近访问过的，而链表后面的数据就是最近最久没有访问过的。如下所示：

代码实现，为了验证上面所提出数据结构是否能通过LeetCode的编译，我们都实现一遍，下面是single list+map的实现，时间复杂度为O(n)+O(lgn)，开始我还以为通过不了，最后还是通过了，耗时大约900ms。

/************************************************************************/
/* 单链表版本                                                                    
/************************************************************************/
struct Node {
    int        m_nKey;
    int        m_nValue;
    Node*    m_pNext;
};

class LRUCache {
public:
    LRUCache(int capacity) {
        m_nSize        = capacity;
        m_nCount    = 0;
        m_lruList    = NULL;
    }

    int get(int key) {
        if (NULL == m_lruList) 
            return -1;
        map<int, Node *>::iterator it = m_lruMap.find(key);
        if (it == m_lruMap.end()) //没有找到
            return -1;
        else {
            Node *p = it->second;
            //把节点移到链表的开头
            pushFront(p);
        }
        return m_lruList->m_nValue;
    }

    void set(int key, int value) {
        if (NULL == m_lruList) {
            m_lruList = new Node();
            m_lruList->m_nKey = key;
            m_lruList->m_nValue = value;
            m_lruList->m_pNext = NULL;
            m_nCount ++;
            m_lruMap[key] = m_lruList;
        }
        else {
            map<int, Node *>::iterator it = m_lruMap.find(key);
            if (it == m_lruMap.end()){ //没有命中,将链表的最后一个节点删除
                if (m_nSize == m_nCount) { //cache已满
                    Node *pHead = m_lruList;
                    Node *pTemp = pHead;
                    while(pHead->m_pNext != NULL) {
                        pTemp = pHead;
                        pHead = pHead->m_pNext;
                    }
                    m_lruMap.erase(pHead->m_nKey);
                    m_nCount --;
                    if (pHead == pTemp) //只有一个节点
                        pHead = NULL;
                    else
                        pTemp->m_pNext = NULL;
                }
                Node *p = new Node(); //插入新的节点于头部
                p->m_nKey = key;
                p->m_nValue = value;
                p->m_pNext = m_lruList;
                m_lruList = p;
                m_lruMap[key] = m_lruList;
                m_nCount ++;
            }
            else { //命中，则将该命中的节点移至链表头部
                Node *pCur = it->second;
                pCur->m_nValue = value;
                pushFront(pCur);
            }
        }
    }

    void pushFront(Node *pCur) {  //把节点移动到链表头部，时间复杂度O(n)
        if (NULL == pCur) 
            return;
        if (m_nCount == 1 || pCur == m_lruList) 
            return;
        Node *pHead = m_lruList;
        while (pHead->m_pNext != pCur) 
            pHead = pHead->m_pNext;
        pHead->m_pNext = pCur->m_pNext;
        pCur->m_pNext = m_lruList;
        m_lruList = pCur;
    }

    void printCache() {
        Node *p = m_lruList;
        while (p) {
            cout << p->m_nKey << ":" << p->m_nValue << " ";
            p = p->m_pNext;
        }
    }

private:
    int                    m_nSize;
    int                    m_nCount;
    map<int, Node *>    m_lruMap;
    Node*                m_lruList;
};

下面是double list+map版本，时间复杂度为O(1)+O(lgn)，耗时大约300s

  1 /************************************************************************/
  2 /* 双链表版本                                                                   
  3 /************************************************************************/
  4 struct Node {
  5     int        m_nKey;
  6     int        m_nValue;
  7     Node*    m_pNext;
  8     Node*   m_pPre;
  9 };
 10 
 11 class LRUCache {
 12 public:
 13     LRUCache(int capacity) {
 14         m_nSize            = capacity;
 15         m_nCount        = 0;
 16         m_lruListHead    = NULL;
 17         m_lruListTail    = NULL;
 18     }
 19 
 20     int get(int key) {
 21         if (NULL == m_lruListHead) 
 22             return -1;
 23         map<int, Node *>::iterator it = m_lruMap.find(key);
 24         if (it == m_lruMap.end()) //没有找到
 25             return -1;
 26         else {
 27             Node *p = it->second;
 28             //把节点移到链表的开头
 29             pushFront(p);
 30         }
 31         return m_lruListHead->m_nValue;
 32     }
 33 
 34     void set(int key, int value) {
 35         if (NULL == m_lruListHead) {
 36             m_lruListHead = new Node();
 37             m_lruListHead->m_nKey = key;
 38             m_lruListHead->m_nValue = value;
 39             m_lruListHead->m_pNext = NULL;
 40             m_lruListHead->m_pPre = NULL;
 41             m_lruListTail = m_lruListHead;
 42             m_nCount ++;
 43             m_lruMap[key] = m_lruListHead;
 44         }
 45         else {
 46             map<int, Node *>::iterator it = m_lruMap.find(key);
 47             if (it == m_lruMap.end()){ //没有命中,将链表的最后一个节点删除
 48                 if (m_nSize == m_nCount) { //cache已满
 49                     if (m_lruListHead == m_lruListTail) {//只有一个节点
 50                         m_lruMap.erase(m_lruListHead->m_nKey);
 51                         m_lruListHead->m_nKey = key;
 52                         m_lruListHead->m_nValue = value;
 53                         m_lruMap[key] = m_lruListHead;
 54                     }
 55                     else {
 56                         Node *p = m_lruListTail;
 57                         m_lruListTail->m_pPre->m_pNext = NULL;
 58                         m_lruListTail = m_lruListTail->m_pPre;
 59                         m_lruMap.erase(p->m_nKey);
 60 
 61                         p->m_nKey = key;
 62                         p->m_nValue = value;
 63                         p->m_pNext = m_lruListHead;
 64                         p->m_pPre = NULL;
 65                         m_lruListHead->m_pPre = p;
 66                         m_lruListHead = p;
 67                         m_lruMap[key] = m_lruListHead;
 68                     }
 69                 }
 70                 else {
 71                     Node *p = new Node(); //插入新的节点于头部
 72                     p->m_nKey = key;
 73                     p->m_nValue = value;
 74                     p->m_pNext = m_lruListHead;
 75                     p->m_pPre = NULL;
 76                     m_lruListHead->m_pPre = p;
 77                     m_lruListHead = p;
 78                     m_lruMap[key] = m_lruListHead;
 79                     m_nCount ++;
 80                 }
 81             }
 82             else { //命中，则将该命中的节点移至链表头部
 83                 Node *pCur = it->second;
 84                 pCur->m_nValue = value;
 85                 pushFront(pCur);
 86             }
 87         }
 88     }
 89 
 90     void pushFront(Node *pCur) {  //把节点移动到链表头部，时间复杂度O(1)
 91         if (NULL == pCur) 
 92             return;
 93         if (m_nCount == 1 || pCur == m_lruListHead) 
 94             return;
 95         if (pCur == m_lruListTail) { //假如是尾节点
 96             pCur->m_pPre->m_pNext = NULL;
 97             pCur->m_pNext = m_lruListHead;
 98             m_lruListTail = pCur->m_pPre;
 99             m_lruListHead->m_pPre = pCur;
100             m_lruListHead = pCur;
101         }
102         else {
103             pCur->m_pPre->m_pNext = pCur->m_pNext;
104             pCur->m_pNext->m_pPre = pCur->m_pPre;
105 
106             pCur->m_pNext = m_lruListHead;
107             m_lruListHead->m_pPre = pCur;
108             m_lruListHead = pCur;
109         }
110     }
111 
112     void printCache() {
113         Node *p = m_lruListHead;
114         while (p) {
115             cout << p->m_nKey << ":" << p->m_nValue << " ";
116             p = p->m_pNext;
117         }
118     }
119 
120 private:
121     int                    m_nSize;
122     int                    m_nCount;
123     map<int, Node *>    m_lruMap;
124     Node*                m_lruListHead;
125     Node*                m_lruListTail;
126 };

下面是hashmap+list版本，如果是C++，list和hashmap都是STL自带的功能实现，所以，我们直接应用STL库，代码量大大减少，时间复杂度为O(1).^-^代码参考：dancingrain

#include <iostream>
#include <hash_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 ;
        hash_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) {
        hash_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中的相应项
                hash_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的内容
    hash_map< int, list<pair<int, int> > :: iterator> cachesMap ;  //使用map加快查找的速度
};

免责声明！

本站转载的文章为个人学习借鉴使用，本站对版权不负任何法律责任。如果侵犯了您的隐私权益，请联系本站邮箱yoyou2525@163.com删除。

猜您在找 leetcode 146. LRU缓存机制 [LeetCode] 146. LRU Cache 最近最少使用页面置换缓存器 LeetCode之LRU Cache 最近最少使用算法缓存设计 146. LRU缓存机制 LeetCode:LRU Cache [leetcode]LRU Cache @ Python [leetcode]LRU Cache LRU Cache leetcode java Leetcode: LRU Cache 解题报告 [LintCode] LRU Cache 缓存器