【算法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("
");
    printf("size = %d
", m_size);
    printf("capacity = %d
", 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
", value);
    lru.PrintList();
    value = lru.Get(2);
    printf("Get(2) = %d
", value);
    lru.PrintList();
    value = lru.Get(4);
    printf("Get(4) = %d
", value);
    lru.PrintList();
    value = lru.Get(1);
    printf("Get(1) = %d
", value);
    lru.PrintList();
    
    return 0;
}