LRUCache

#include <stdexcept>
#include <list>
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>

typedef struct vkt
{
    int v;
    int k;
    unsigned int t;
}vkt_t, *vkt_p;

inline bool time_comp(const vkt_p& l, const vkt_p& r)
{
    return l->t < r->t;
}

typedef std::map<int, vkt_p> kvtk_map;

typedef std::map<int, int> tk_map;

class LRUCache
{
private:
    const int _capacity;

    std::vector<vkt_p> vkt_buf;

    vkt_p ori_buf;

    kvtk_map kvtk;

    tk_map   tk;

    const unsigned int max_time;

    unsigned int guard;

protected:
    vkt_p new_vkt(void)
    {
        if (vkt_buf.empty())
            return NULL;
        vkt_p p = vkt_buf.back();
        vkt_buf.pop_back();
        return p;
    }

    void del_vkt(vkt_p p)
    {
        vkt_buf.push_back(p);
    }

    void adjust_time()
    {
        if (guard >= max_time)
        {
            tk.clear();

            std::list<vkt_p> lv;

            for (kvtk_map::const_iterator iter = kvtk.begin(); iter != kvtk.end(); ++iter)
            {
                lv.push_back(iter->second);
            }
           
            lv.sort(time_comp);

            int i = 0;

            for (kvtk_map::const_iterator iter = kvtk.begin(); iter != kvtk.end(); ++iter)
            {
                iter->second->t = i++;
            }

            guard = i;

            for (std::list<vkt_p>::const_iterator iter = lv.begin(); iter != lv.end(); ++iter)
            {
                tk.insert(std::make_pair((*iter)->t, (*iter)->k));
            }
        }
    }


public:
    LRUCache(int capacity) : _capacity(capacity + 1), max_time(~0), guard(0)
    {
        if (capacity <= 0)
            throw std::invalid_argument("capacity must > 0");

        ori_buf = new vkt_t[_capacity];

        vkt_buf.reserve(_capacity);

        for (int i = 0; i < _capacity; ++i)
        {
            vkt_buf.push_back(ori_buf + i);
        }
    }

    ~LRUCache() { delete[] ori_buf; ori_buf = NULL; }

    int get(int key) 
    {
        kvtk_map::iterator iter = kvtk.find(key);
        if (iter == kvtk.end())
            return -1;

        tk_map::iterator tkiter = tk.find(iter->second->t);
        if (tkiter != tk.end())
            tk.erase(tkiter);

        iter->second->t = guard++;

        int v = iter->second->v;

        tk.insert(std::make_pair(iter->second->t, key));

        adjust_time();

        return v;
    }

    void set(int key, int value) 
    {
        kvtk_map::iterator iter = kvtk.find(key);
        if (iter == kvtk.end())
        {
            vkt_p p = new_vkt();
            if (p != NULL)
            {
                p->v = value; p->k = key; p->t = guard;
                iter = kvtk.insert(std::make_pair(key, p)).first;
            }
        }
        if (iter != kvtk.end())
        {
            tk_map::iterator tkiter = tk.find(iter->second->t);
            
            if (tkiter != tk.end())
                tk.erase(tkiter);

            iter->second->t = guard++;
            
            iter->second->v = value;

            tk.insert(std::make_pair(iter->second->t, key));
        }

        if (kvtk.size() == _capacity)
        {
            tk_map::iterator tkiter = tk.begin();
            
            if (tkiter != tk.end())
            {
                int k = tkiter->second;
                
                tk.erase(tkiter);

                kvtk_map::iterator iter = kvtk.find(k);
             
                if (iter != kvtk.end())
                {
                    del_vkt(iter->second);
                    kvtk.erase(iter);
                }
            }
        }
        
        adjust_time();
    }

    int size(void) const { return (int)kvtk.size(); }

    int old_val(void) const 
    {
        tk_map::const_iterator tkit = tk.begin();

        if (tkit != tk.end())
        {
            kvtk_map::const_iterator kvtkit = kvtk.find(tkit->second);
            if (kvtkit != kvtk.end())
                return kvtkit->second->v;
        }

        return -1;
    }

    int new_val(void) const 
    {
        tk_map::const_reverse_iterator tkit = tk.rbegin();

        if (tkit != tk.rend())
        {
            kvtk_map::const_iterator kvtkit = kvtk.find(tkit->second);
            if (kvtkit != kvtk.end())
                return kvtkit->second->v;
        }

        return -1;
    }
};

#include <cassert>

int main(int argc, char* argv[])
{
    LRUCache lru(10);

    assert(-1 == lru.get(0));

    for (int i = 0; i < 0xFF0; ++i)
    {
        lru.set(i, i);
    }

    assert(lru.size() == 10);

    for (int i = 0; i < 100; ++i)
    {
        lru.set(i, i);
    }

    assert(lru.size() == 10);

    assert(lru.get(5) == -1);

    assert(lru.get(95) == 95);

    assert(lru.get(100) == -1);

    assert(lru.new_val() == 95);

    assert(lru.old_val() == 90);

    lru.set(4, 10);

    assert(lru.new_val() == 10);

    assert(lru.old_val() == 91);

    assert(lru.get(0) == -1);

    lru.set(0, 0);

    assert(lru.new_val() == 0);

    assert(lru.old_val() == 92);

    return 0;
}