【算法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(), value(), 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 = ;
     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 == )
     {
         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 -;
     }

     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();
     lru.Put(, );
     lru.PrintList();
     lru.Put(, );
     lru.PrintList();
     lru.Put(, );
     lru.PrintList();
     lru.Put(, );
     lru.PrintList();
     int value = lru.Get();
     printf("Get(3) = %d\n", value);
     lru.PrintList();
     value = lru.Get();
     printf("Get(2) = %d\n", value);
     lru.PrintList();
     value = lru.Get();
     printf("Get(4) = %d\n", value);
     lru.PrintList();
     value = lru.Get();
     printf("Get(1) = %d\n", value);
     lru.PrintList();

     return ;
 }