leetcode-145-LRU cache

问题

题目：[leetcode-145]

思路

参考了[O(1) unordered_map + list + splice]
参考者代码的思路非常清晰。
首先，插入和获取的时间复杂度在O(1)，不能用deque去实现。否则无法到达常数。采用链表，插入，删除的时间复杂度都是o(1)。需要双向链表，可以自己实现。可以使用stl::list. 由于链表不支持随机访问，所以，做一次哈希。

代码

class LRUCache {
public:
    LRUCache(int capacity) : cap_(capacity) {}

    int get(int key) {
        if( cache_map_.find(key) == cache_map_.end() ) return -1;
        else{
            int val = cache_map_[key]->val;
            cache_list_.splice( cache_list_.begin(), cache_list_, cache_map_[key] );
            return val;
        }
    }

    void put(int key, int value) {
        if( cache_map_.find(key) != cache_map_.end() ){
            cache_map_[key]->val = value;
            cache_list_.splice(cache_list_.begin(), cache_list_, cache_map_[key]);
        }else{
            element e(key, value);
            if(cache_list_.size() < cap_){
                cache_list_.push_front(e);
                cache_map_[key] = cache_list_.begin();
            }else{
                cache_map_.erase(cache_list_.back().key);
                cache_list_.pop_back();

                cache_list_.push_front(e);
                cache_map_[key] = cache_list_.begin();
            }
        }
    }
private:
    struct element{
        int key;
        int val;
        element(): key(0),val(0){}
        element(int k, int v) : key(k), val(v){}
    };
    std::list<element> cache_list_;
    std::unordered_map< int, std::list<element>::iterator > cache_map_;
    int cap_;
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

代码1

自己实现了循环双链表，注意pop_back的时候，别忘了从哈希表删除。

class LRUCache {
public:
    LRUCache(int capacity) : cap_(capacity), size_(0) {
        head_ = tail_ = new Node();
        assert(head_);
        assert(cap_);
    }

    int get(int key) {
        std::cout << "get: " << key << std::endl;
        if( cache_map_.find(key) == cache_map_.end() ) return -1;
        else{
            CacheList p = cache_map_[key];
            move_to_head(p);
            return p->val;
        }
    }

    void put(int key, int value) {
        std::cout << "put: " << key << "," << value << std::endl;
        if( cache_map_.find(key) != cache_map_.end() ){
            CacheList p = cache_map_[key];
            p->val = value;
            move_to_head(p);
        }else{
            CacheList p = new Node();
            p->key = key;
            p->val = value;
            ++size_;
            if(size_ <= cap_){
                insert_head(p);
                cache_map_[key] = p;
            }else{
                size_ = cap_;

                cache_map_.erase(tail_->key);
                delete_tail();

                insert_head(p);
                cache_map_[key] = p;
            }
        }
    }
    ~LRUCache() { delete head_; }
private:
    struct Node {
        int key;
        int val;
        Node* next;
        Node* prev;
        Node() { memset(this, 0, sizeof(Node));}
    };
    typedef Node* CacheList;

    CacheList head_;
    CacheList tail_;
    int cap_;
    int size_;
    unordered_map<int, CacheList> cache_map_;
private:    
    void move_to_head(CacheList p){
        if( head_ == tail_ ) return ;
        if( head_->next == p ) return ;
        else{
            if(p == tail_){
                tail_ = tail_->prev;
                tail_->next = NULL;
            }
            else{
                CacheList pre = p->prev;
                CacheList nex = p->next;
                pre->next = nex;
                nex->prev = pre;
            }
            insert_head(p);
        }
    }
    void insert_head(CacheList p){
        CacheList q = head_->next;

        p->next = q;
        p->prev = head_;
        head_->next = p;
        if(q) q->prev = p;
        else tail_ = p;
    }
    void delete_tail(){
        if(head_ == tail_) return;
        CacheList p = tail_;
        tail_ = tail_->prev;
        tail_->next = NULL;

        delete p;
    }
};

代码２

bug在于，要区别两类迭代器。不是一回事！

class LRUCache {
public:
    LRUCache(int capacity) {
        cap_ = capacity;
    }

    int get(int key) {
        if( cache_map_.find(key) == cache_map_.end() ) return -1;
        else{
            Iter it = cache_map_[key];
            // move to head
            cache_list_.splice( cache_list_.begin(), cache_list_, it );

            // return value
            return it->second;
        }
    }

    void put(int key, int value) {
        if( cache_map_.find(key) != cache_map_.end() ){
            Iter it = cache_map_[key];
            // update the value
            it->second = value;

            // move to head
            cache_list_.splice( cache_list_.begin(), cache_list_, it );
        }
        else{
            if( cache_list_.size() == cap_ ){
                cache_map_.erase( cache_list_.back().first );
                cache_list_.pop_back();
            }

            Node node(key, value);

            cache_list_.push_front(node);
            cache_map_[key] = cache_list_.begin();
        }
    }
private:
    typedef pair<int, int> Node;
    typedef list<Node>::iterator Iter;

    list<Node> cache_list_;
    unordered_map<int, Iter> cache_map_;
    int cap_;
};