LRU Cache -- LeetCode

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

题目描述如上，就是设计一个数据结构，实现LRU算法，支持两种操作，get（查询key对应的value),和set(将key,value加入集合中)

首先，我用双向链表实现，代码细节需要注意的地方较多，因为是处理指针。

class LRUCache{
public:
    class Node {
    public:
        int key, value;
        Node *prv, *nxt;
        Node():key(0), value(0), prv(NULL), nxt(NULL) {}
        Node(int key, int val):key(key), value(val), prv(NULL), nxt(NULL) {}
    };
    class DoubleLinkedList {
    public:
        Node *head, *tail;
        int size, capacity;
        DoubleLinkedList():size(0), capacity(0), head(NULL), tail(NULL) {}
        DoubleLinkedList(int c):size(0), capacity(c), head(NULL), tail(NULL) {}
        /*~DoubleLinkedList() {
            while (head != NULL) {
                Node *tmp = head;
                head = head->nxt;
                delete tmp;
            }
        }*/
        void erase(Node *it) {
            if (size == 0) return ;
            if (it->prv != NULL && it->nxt != NULL) {
                it->prv->nxt = it->nxt;
                it->nxt->prv = it->prv;
            }
            if (it->prv == NULL) {
                head = it->nxt;
                if (head != NULL)
                    head->prv = NULL;
            }
            if (it->nxt == NULL) {
                tail = it->prv;
                if (tail != NULL)
                    tail->nxt = NULL;
            }
            size--;
        }
        int insert(Node *it) {
            if (tail != NULL) {
                tail->nxt = it;
                it->nxt = NULL;
                it->prv = tail;
                tail = it;
            } else {
                head = tail = it;
            }
            //if (head == NULL) head = it;
            //if (tail == NULL) tail = it;
            size++;
            if (size > capacity && size > 0) {
                int key = head->key;
                if (size == 1) {
                    delete head;
                    head = tail = NULL;
                } else {
                    Node *tmp = head;
                    head = head->nxt;
                    head->prv = NULL;
                    delete tmp;
                    tmp = NULL;
                }
                size--;
                return  key;
            }
            return -1;
        }
    };
    LRUCache(int capacity) {
        //DoubleLinkedList DLL(capacity);
        DLL.capacity = capacity;
    }
    
    int get(int key) {
        if (HashMap.find(key) == HashMap.end()) {
            return -1;
        } else {
            Node *it = HashMap[key];
            DLL.erase(it);
            DLL.insert(it);
            return (it->value);
        }
    }
    
    void set(int key, int value) {
        if (HashMap.find(key) != HashMap.end()) {
            Node *it = HashMap[key];
            it->value = value;
            DLL.erase(it);
            DLL.insert(it);
        } else {
            Node *tmp = new Node(key, value);
            HashMap.insert(pair<int, Node*>(key, tmp));
            int k = DLL.insert(tmp);
            if (k != -1) HashMap.erase(k);
        }
    }
    
private:
    unordered_map<int, Node*> HashMap;
    DoubleLinkedList DLL;
};

后来，有人说可以用list来简化代码，我原以为面试的时候应该尽量少的使用STL等高级手段，后来巨巨们说并不是这样，于是就用list实现了一遍。

class LRUCache{
public:
    LRUCache(int c) {
        capacity = c;
    }
    
    int get(int key) {
        int ans = -1;
        auto it = disc.find(key);
        if (it != disc.end()) {
            ans = it->second->second;
            data.erase(it->second);
            data.push_front(pair<int, int>(key, ans));
            disc[key] = data.begin();
        }
        return ans;
    }
    
    void set(int key, int value) {
        auto it = disc.find(key);
        if (it != disc.end()) {
            data.erase(it->second);
            data.push_front(pair<int, int>(key, value));
            disc[key] = data.begin();
        } else {
            data.push_front(pair<int, int>(key, value));
            disc[key] = data.begin();
            if (data.size() > capacity) {
                auto it2 = data.end(); it2--;
                int k = it2->first;
                disc.erase(k);
                data.pop_back();
            }
        }
    }
private:
    unordered_map<int, list<pair<int, int> >::iterator > disc;
    list<pair<int, int> > data; 
    int capacity;
};

代码较之前短了很多，但是时间效率也是慢了一倍。

后来听说到有个东西unique_ptr，智能指针，虽然没有使用过，不过还是看了下介绍，可以省去delete操作，方便而且不容易出错。

另外，在使用list解答　本题的时候发现原来我一直没有真正理解迭代器这个概念。我们熟悉的指针也是一种迭代器，但是不可以说迭代器就是指针。

比如，数组下标也是一种迭代器，但是他就不是地址。

当使用list.erase(it)操作时，他返回的是下一个元素的迭代器，而it对应的元素已经被销毁，所以it不可以继续使用，

可以这样：

it = list.erase(it)

或者：

list.erase(it++)

下面一种方法中，在it被erase之前，已经做了一次后自增，所以此时的it是指向下一个元素的，删除了的是it之前的那个元素。