算法学习 - LRUCache学习(C++)

LRUCache解释

LRUCache就是一个缓存系统，主要是在操作系统中用的比较多，我这里实现的仅仅是一个简单的方法，原理是正确的，但是操作系统的内部的缓存代码我并没有看过。

LRU是Least Recently Used的意思，Cache大家都知道是缓存的意思了。就是在缓存里保存最近最常使用的元素，这样访问这些元素的时候，速度就比较快的能访问到了。

缓存里存放的一般都是键值对，就是(key, value)的结构，大致最简单的就是有两种操作：

1. 一种是get(key)，这个方法是从缓存里查找是否有key的元素，有的话返回其value值，没有的话返回-1。
2. 一种是set(key , value)，这个方法是假如缓存里没有key的元素，那么放到缓存里，假如缓存已经满了，把最不常用的那个(key, value)给扔掉，再把新元素放进去。假如缓存里已经有key的元素了，那么更新key的value值。

代码实现

大家应该都明白这是一个什么系统了，下面放上我的代码实现：

//
//  main.cpp
//  LRUCache
//
//  Created by Alps on 14/12/5.
//  Copyright (c) 2014年 chen. All rights reserved.
//

#include <iostream>
#include <map>
using namespace std;

class LRUCache{
public:
    struct Node{
        int key;
        int value;
        Node* next;
        Node* pre;
        Node(int k, int v):key(k), value(v), next(NULL), pre(NULL){}
    };
    int maxsize;
    int cursize;
    typedef Node* Keynode;
    map<int ,Keynode> cachemap;
    Keynode head;
    Keynode tail;
    LRUCache(int capacity) {
        head = new Node(-1,-1);
        tail = new Node(-1,-1);
        head->next = tail;
        tail->pre = head;
        maxsize = capacity;
        cursize = 0;
    }
    
    void insertHead(Keynode node){
        node->next = head->next;
        node->pre = head;
        head->next->pre = node;
        head->next = node;
    }
    
    void deleteNode(Keynode node){
        node->pre->next = node->next;
        node->next->pre = node->pre;
    }
    
    int get(int key) {
        map<int, Keynode>::iterator iter;
        iter = cachemap.find(key);
        if (iter == cachemap.end()) {
            return -1;
        }else{
            Keynode temp = iter->second;
            deleteNode(temp);
            insertHead(temp);
            return temp->value;
        }
        return -1;
    }
    
    void set(int key, int value) {
        map<int, Keynode>::iterator iter;
        iter = cachemap.find(key);
        if (iter == cachemap.end()) {
            if (cursize >= maxsize) {
                Keynode freenode = tail->pre;
                cachemap.erase(freenode->key);
                deleteNode(freenode);
                free(freenode);
                Keynode temp = (Keynode)malloc(sizeof(struct Node));
                *temp = Node(key,value);
                insertHead(temp);
                cachemap[key] = temp;
            }else{
                Keynode temp = (Keynode)malloc(sizeof(struct Node));
                *temp = Node(key,value);
                insertHead(temp);
                cursize++;
                cachemap[key] = temp;
            }
        }else{
            Keynode temp = iter->second;
            temp->value = value;
            deleteNode(temp);
            insertHead(temp);
        }
    }
};

int main(int argc, const char * argv[]) {
    LRUCache L(2);
    L.set(2, 1);
    L.set(2, 2);
    int v = L.get(2);
    L.set(1, 1);
    L.set(4, 1);
    
    printf("%d\n",v);
    printf("%d\n",L.get(2));
    return 0;
}