[LeetCode]LRU Cache有个问题，求大神解答【已解决】

题目：

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.

这是我的代码：

class LRUCache{
public:
    int num;
    int max;
    list<int> latest_key;　　　　　　　　 //用于保存使用情况，队头是最久未使用的，队尾是最近使用的
    unordered_map<int, int> cache;　　　//用于保存key,value

    LRUCache(int capacity) {
        num = 0;
        max = capacity;
    }

    int get(int key) {
        unordered_map<int, int>::iterator it = cache.find(key);
        list<int>::iterator iter;
        if (it == cache.end())　　//如果没有找到key
            return -1;
        else　　　　　　　　　　　　//如果找到了key，就在对应的最近latest队列里面修改key的位置，先把key所在的位置删除，再把key放到队尾
        {
            iter = latest_key.begin();
            while (*iter != key)
                iter++;
            latest_key.erase(iter);
            latest_key.push_back(key);
            return it->second;
        }
    }

    void set(int key, int value) {
        unordered_map<int, int>::iterator it = cache.find(key);
        list<int>::iterator iter;
        if (it != cache.end())　　//如果要插入的已经有key存在，就先在优先队列里面找到key出现的位置，删除，再把key插入队尾
        {
            it->second = value;
            iter = latest_key.begin();
            while (*iter != key)
                iter++;
            latest_key.erase(iter);
            latest_key.push_back(key);
        }
        else　　　　　　　　　　　　//如果要插入的不存在
        {
            if (num<max)　　//如果不超过cache容量，则直接在cahe中插入，再在队尾添加该key
            {
                num++;
                cache.insert(std::pair< int, int >(key, value));
                latest_key.push_back(key);
            }
            else　　　　　　//如果cache已经满了，则根据队头元素，在cache删除对应键值，再在队列中删除这个队头，之后，把新要插入的键值插入cache中，把新key插入队尾
            {
                int latest = latest_key.front();
                cache.erase(latest);
                latest_key.pop_front();
                cache.insert(std::pair< int, int >(key, value));
                latest_key.push_back(key);
            }
        }
    }
};

　　当我把代码中出现：

 iter = latest_key.begin();
 while (*iter != key)
    iter++; 

　　部分替换为：

iter=find(latest_key.begin(),latest_key.end(),key);

　　就会报错：

Time Limit Exceeded

Last executed input: 2048,[set(1178,3401),set(903,6060).....

　　我大致查了一下find的实现机制，也是遍历啊，按理说这两者效率差不多，为什么替换之后就不能通过？而替换之前能通过，求大神解答！！

　　万分感谢！！！

　　在Leetcode上问，已经得到答案：

　　之前的那个算法效率确实不高，压线过的，修改了原有代码，增加了一个unordered_map<int, list<int>iterator>用来索引list，可以使时间复杂度降到O(1)：

class LRUCache{
private:
    unordered_map<int, int> cache;
    unordered_map<int, list<int>::iterator> find_key;
    list<int> latest_key;
    int max;
public:
    LRUCache(int capacity) : max(capacity){

    }

    int get(int key) {
        if (cache.find(key) == cache.end()){
            return -1;
        }
        latest_key.erase(find_key[key]);
        latest_key.push_front(key);
        find_key[key] = latest_key.begin();
        return cache[key];
    }

    void set(int key, int value) {
        if (cache.find(key) == cache.end()) {
            if (cache.size() >= max) {
                cache.erase(latest_key.back());
                latest_key.pop_back();
                cache[key] = value;
                latest_key.push_front(key);
                find_key[key] = latest_key.begin();
            }
            else {
                cache[key] = value;
                latest_key.push_front(key);
                find_key[key] = latest_key.begin();
            }
        }
        else {
            cache[key] = value;
            latest_key.erase(find_key[key]);
            latest_key.push_front(key);
            find_key[key] = latest_key.begin();
        }
    }
};