題目描述：

運用你所掌握的資料結構，設計和實現一個  LRU (最近最少使用) 快取機制。它應該支援以下操作： 獲取資料 get 和 寫入資料 put 。

獲取資料 get(key) - 如果金鑰 (key) 存在於快取中，則獲取金鑰的值（總是正數），否則返回 -1。
寫入資料 put(key, value) - 如果金鑰不存在，則寫入其資料值。當快取容量達到上限時，它應該在寫入新資料之前刪除最近最少使用的資料值，從而為新的資料值留出空間。

進階:

你是否可以在 O(1) 時間複雜度內完成這兩種操作？

示例:

LRUCache cache = new LRUCache( 2 /* 快取容量 */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 該操作會使得金鑰 2 作廢
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 該操作會使得金鑰 1 作廢
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

解題方案：

新題型，屬於C++設計的題型，需要自己去定義很多變量了。

自己寫的程式碼，但是花費了過多的時間：

class LRUCache {
public:
    LRUCache(int capacity):size(capacity) {}
    
    int get(int key) {
        auto it = hash.find(key);
        if(it == hash.end())
            return -1;
        put(key, hash[key]);
        return hash[key];
    }
    
    void put(int key, int value) {
        auto it = find(cache.begin(), cache.end(), key);
        if(it != cache.end()){
            cache.erase(it);
            cache.push_back(key);
            hash[key] = value;
        }
        else if(cache.size() == size){
            hash.erase(cache.front());
            cache.pop_front();
            cache.push_back(key);
            hash.insert(pair<int, int>(key, value));
        }
        else{
            cache.push_back(key);
            hash.insert(pair<int, int>(key, value));
        }
    }

private:
    int size;
    map<int, int> hash;
    list<int> cache;
};

/**
 * 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);
 */
 

最終答案給出的時間開銷最小的程式碼：

static int x = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(NULL);
    return 0;
}();

struct Node
{
    int key;
    int val;
    Node* left;
    Node* right;
    
    Node(int k, int v): key(k), val(v), left(NULL), right(NULL) {}
};

class LRUCache {
public:
    LRUCache(int capacity) {
        
        mCapacity = 0;
        mStored = 0;
        
        head = NULL;
        tail = NULL;
        
        if (capacity > 0)
        {
            mCapacity = capacity;
            mData.assign(capacity, Node(0, 0));
        }
    }
    
    int get(int key) {
        auto it = mDict.find(key);
        if (it == mDict.end())
        {
            return -1;
        }
        
        moveToTail(it->second);
        
        return tail->val;
    }
    
    void put(int key, int value) {
        
        if (mCapacity <= 0)
        {
            return;
        }
        
        auto it = mDict.find(key);
        if (it != mDict.end())
        {
            // 已存在快取中的key，更新其val，將其移動到隊尾即可
            it->second->val = value;
            
            moveToTail(it->second);
            
            return;
        }
        
        if (mStored < mCapacity)
        {
            // 快取還未放滿
            Node* p = &mData[mStored];
            
            p->key = key;
            p->val = value;
            
            if (mStored == 0)
            {
                head = p;
                tail = p;
            }
            else
            {
                tail->right = p;
                p->left = tail;
                p->right = NULL;
                tail = p;
            }
            
            mDict.insert({key, p});
            
            mStored++;    
        }
        else
        {
            // 快取已滿，清除最久未使用的快取值
            Node* p = head;
            
            head = head->right;
            
            if (head != NULL)
            {
                head->left = NULL;
            }
            
            mDict.erase(p->key);
            
            p->key = key;
            p->val = value;
            
            tail->right = p;
            p->left = tail;
            p->right = NULL;
            tail = p;
            
            mDict.insert({key, p});
        }
    }
private:
    unordered_map<int, Node*> mDict;

    Node* head;
    Node* tail;
    
    vector<Node> mData;
    
    int mCapacity;
    int mStored;
    
    void moveToTail(Node* cur)
    {
        if (cur == tail)
        {
            return;
        }
        
        auto nl = cur->left;
        auto nr = cur->right;
            
        if (nl == NULL)
        {
            head = nr;
        }
        else
        {
            nl->right = nr;
        }
            
        nr->left = nl;
            
        tail->right = cur;
        cur->left = tail;
        cur->right = NULL;    
        
        tail = cur;
    }
};

/**
 * 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);
 */