【算法33】LRU算法

題目來源

LeetCode： https://leetcode.com/problems/lru-cache/

LRU簡介

LRU （Least Recently Used，最近最少使用）算法是操作系統中一種經典的頁面置換算法，當發生缺頁中斷時，需要將內存的一個或幾個頁面換出，LRU指出應該將內存最近最少使用的那些頁面進行換出，依據的是程序的局部性原理，最近經常使用的頁面在不久的將來也很有可能被使用，反之最近很少使用的頁面未來也不太可能再使用。

LRU 數據結構

LRU采用雙向鏈表+hash表的數據結構實現，雙向鏈表作為隊列存儲當前緩存節點，其中從表頭到表尾的元素按照最近使用的時間進行排列，放在表頭的是最近剛剛被使用過的元素，表尾的最近最少使用的元素；如果僅僅采用雙向鏈表，那么查詢某個元素需要 O(n) 的時間，為了加快雙向鏈表中元素的查詢速度，采用hash表講key進行映射，可以在O(1)的時間內找到需要節點。

LRU主要實現以下兩個接口：

int Get(int key);
void Put(int key, int value);

其中 Get 用來讀取隊列中的元素，同時需要將該元素移動到表頭；Put 用來向隊列中插入元素。

LRU 具體實現

從實現的角度來看，每次 Get 時， 需要判斷該 key 是否在隊列中，如果不在，返回-1；如果在，需要重新移動該元素到表頭位置（具體實現，可以先刪除，在插入到表頭）。 每次 Put 時，首先需要判斷key是否在隊列中，如果在，那么更新其 value值，然后移動該元素到表頭即可；如果不在，需要進一步判斷，隊列是否已滿，如果已滿；那么需要首先刪除隊尾元素，並對 size - 1， 刪除哈希表中對應元素的 key；然后在插入新的元素到隊頭。

具體C++代碼如下：

/**
 * LRU Cache Implementation using DoubleLinkList & hashtable
 * Copyright 2015 python27
 * 2015/06/26
 */
#include <iostream>
#include <string>
#include <map>
#include <list>
#include <deque>
#include <cassert>
#include <cstdio>
#include <cstdlib>
using namespace std;

struct CacheNode
{
    int key;
    int value;
    CacheNode* prev;
    CacheNode* next;
    
    CacheNode(int k, int v) : key(k), value(v), prev(NULL), next(NULL)
    {}
    
    CacheNode():key(0), value(0), prev(NULL), next(NULL)
    {}        
};

class LRUCache
{
public:
    LRUCache(int capacity);
    
    int Get(int key);
    void Put(int key, int value);
    
public:
    void PrintList() const;
private:
    void InsertNodeFront(CacheNode* p);
    void DeleteNode(CacheNode* p);
    
private:
    map<int, CacheNode*> m_hashtable;        // hash table
    CacheNode* m_head;                        // double link list head
    CacheNode* m_tail;                        // double link list tail
    int m_capacity;                            // capacity of link list
    int m_size;                                // current size of link list
};

void LRUCache::PrintList() const
{
    CacheNode* p = m_head;
    for (p = m_head; p != NULL; p = p->next)
    {
        printf("(%d, %d)->", p->key, p->value);
    }
    printf("\n");
    printf("size = %d\n", m_size);
    printf("capacity = %d\n", m_capacity);
}

LRUCache::LRUCache(int capacity)
{
    m_capacity = capacity;
    m_size = 0;
    m_head = NULL;
    m_tail = NULL;
}

//    insert node into head pointed by p
void LRUCache::InsertNodeFront(CacheNode* p)
{
    if (p == NULL) return;
    
    if (m_head == NULL)
    {
        m_head = p;
        m_tail = p;
    }
    else
    {        
        p->next = m_head;
        m_head->prev = p;
        m_head = p;
    }
}

// delete node in double linklist pointed by p
void LRUCache::DeleteNode(CacheNode* p)
{
    if (p == NULL) return;
    
    assert(m_head != NULL && m_tail != NULL);
    
    if (m_size == 1)
    {
        if (p == m_head && p == m_tail)
        {
            delete p;
            m_head = NULL;
            m_tail = NULL;
        }
        else
        {
            fprintf(stderr, "Delete Wrong! No such Node");
            return;
        }
    }
    else if (p == m_head)
    {
        m_head = m_head->next;
        m_head->prev = NULL;
        delete p;
    }
    else if (p == m_tail)
    {
        m_tail = m_tail->prev;
        m_tail->next = NULL;
        delete p;
    }
    else
    {
        p->prev->next = p->next;
        p->next->prev = p->prev;
        delete p;
    }
    
}

int LRUCache::Get(int key)
{
    // if key not in return -1
    if (m_hashtable.find(key) == m_hashtable.end())
    {
        return -1;
    }
        
    CacheNode* p = m_hashtable[key];
    int k = p->key;
    int v = p->value;
    
    // delete this node
    DeleteNode(p);
        
    // insert this node to the head
    p = new CacheNode(k, v);
    InsertNodeFront(p);
    // update hash table
    m_hashtable[k] = p;
    return p->value;
}

void LRUCache::Put(int key, int value)
{
    // if key alread in, update
    if (m_hashtable.find(key) != m_hashtable.end())
    {
        CacheNode* p = m_hashtable[key];
        
        // delete node
        DeleteNode(p);
        // insert node
        p = new CacheNode(key, value);
        InsertNodeFront(p);
        // update hash table
        m_hashtable[key] = p;
        return;
    }
    // if list is full, delete the tail node
    else if (m_size >= m_capacity)
    {
        // delete the tail node
        CacheNode* p = m_tail;
        m_hashtable.erase(p->key);
        DeleteNode(p);
        m_size--;
    }
    
    // create node and insert into head
    assert(m_size < m_capacity);
    CacheNode* p = new CacheNode(key, value);
    InsertNodeFront(p);
    m_hashtable[key] = p;
    m_size++;
}

int main()
{
    LRUCache lru(3);
    lru.Put(1, 11);
    lru.PrintList();
    lru.Put(2, 22);
    lru.PrintList();
    lru.Put(3, 33);
    lru.PrintList();
    lru.Put(4, 44);
    lru.PrintList();
    int value = lru.Get(3);
    printf("Get(3) = %d\n", value);
    lru.PrintList();
    value = lru.Get(2);
    printf("Get(2) = %d\n", value);
    lru.PrintList();
    value = lru.Get(4);
    printf("Get(4) = %d\n", value);
    lru.PrintList();
    value = lru.Get(1);
    printf("Get(1) = %d\n", value);
    lru.PrintList();
    
    return 0;
}