LRU的C++实现引申出的迭代器问题

leetcode上刷题。碰到一题实现LRU算法的题目。

LRU，Least recently used。是一种常见的cache和页面替换算法。算法和原理可以参阅相关wiki。

leetcode上的这一题，时间要求很苛刻，如果达不到O(1)复杂度的话，基本上会TLE。

所以，这一题如果用C++来解的话，需要用到list和unordered_map。其中unordered_map是C++11标准提供hash_map的实现。

实现LRU需要注意两点：一是必须保持list的有序，因为其先后关系体现了其最近调用的频次，二是查询必须快准狠，查询list中相关cache必须在O(1)内完成，决不允许遍历list实现。

这下问题来了。又要有序，又要hash。这如何是好？

google了一下，发现一个帖子。地址：https://groups.google.com/forum/#!topic/comp.lang.c++.moderated/bgOd8zMc65k

Q:

I have recently started using java and have come across
the
LinkedHashMap. For those not in the know this is like a hash
table (ie
fast indexing via hash function) but also has the neat
feature where
iterating through the table the entries are
retrieved in the order
they were inserted. This is really useful
when implementing caches. I
wonder what plans there are (if any)
for a similar class in the std
library?

A:

The suggestions are to store your data in one data structure, and
then
store the iterators in another. Currently, C++ does not
actually
guarantee the presence of a hash map, though your implementation
may
provide one. The basic suggestion is that if you store your
iterators
to std::unordered_map in a list, then you can add an iterator
each
time to add to the map, effectively recording how things are
accessed.
The data iterators provide very fast data to any individual element
as
well.

If you want to create a class that wraps this featureset, you‘ll have
to
do it yourself, though. There doesn‘t exist any pre-written
functionality for
this.

意思是说，java中有一个linkedhashmap类型，比较容易拿来实现cache类算法，问c++是否有对应实现

回答的说，可以自己写，用list和unordered_map。

里面有一个思路很亮，将iterator存在hash_map中。。。也就是hash表结构为hash(key, [value,iterator])

等等，将iterator保存起来？我见过的iterator不是用来遍历container的么？还有这种新奇的用法？我记得好像会有迭代器失效的问题啊。

不管如何，我还是按照这个方法实现了下，果然很快AC了。

AC不行啊，为什么要这样用iterator。。

下面，就来探究探究iterator到底有哪些诡异的地方。

解决C++语言类细节，有两个网站必须去的

https://www.sgi.com/tech/stl/

http://www.cplusplus.com/

所以，其实一切的缘由皆在其中。

首先明确，迭代器，不只有一种，可以划分为更多细小的类型。下图说明了一切

The properties of each iterator category are:

可以看到，不同的迭代器支持的操作都不太一样。详细可参阅相关文档。

同样是iterator，vector和list支持的操作就不一样。也就是说，不同的container的iterator性质不一样。

vector的iterator可以有如下操作 v.begin()+1

而list的iterator这样做是编译通不过的 l.begin()+1

why?

根据文档，list的iterator是

Member
types iterator and const_iterator are bidirectional
iterator types (pointing to an element and to a const element,
respectively).

对应上表，知道为什么了吧。

同理，vector的iterator是Random Access。

所以，不同container的iterator操作一定要仔细辨别。

其实，这么规定也是有缘由的，链表本来就不支持随机访问，不是么，而连续数组则可以。

第二个问题，iterator invalidation。即迭代器失效的问题。

这个问题比较隐晦，一般而言vector这类的容器在修改容器内容后，容器内存有可能重新分配，从而导致迭代器指向的位置是个junk。

下面是文档描述：

vector:

Memory will be reallocated automatically if more
than capacity() - size() elements are inserted
into the vector. Reallocation does not change size(),
nor does it change the values of any elements of the vector. It does, however,
increase capacity(), and it
invalidates [5] any
iterators that point into the vector.

A vector‘s iterators are invalidated when its memory is
reallocated. Additionally, inserting or deleting an element in the middle of a
vector invalidates all iterators that point to elements following the insertion
or deletion point. It follows that you can prevent a vector‘s iterators from
being invalidated if you use reserve() to
preallocate as much memory as the vector will ever use, and if all insertions
and deletions are at the vector‘s end.

但是对于list而言，就不是这么回事了

Alist is exactly the opposite:
iterators will not be invalidated, and will not be made to point to different
elements, but, for list iterators, the
predecessor/successor relationship is not invariant.

A similar property holds for all versions
of insert() and erase(). List<T,
Alloc>::insert() never invalidates any iterators,
and list<T, Alloc>::erase() only
invalidates iterators pointing to the elements that are actually being
erased.

The ordering of iterators may be changed (that
is, list<T>::iterator might have a
different predecessor or successor after a list operation than it did before),
but the iterators themselves will not be invalidated or made to point to
different elements unless that invalidation or mutation is explicit.

所以，这就是为什么可以用hash_map来保存list的iterator而不会出现iterator失效的问题。

顺便总结一下其余的容器迭代器特性

Map has the important property that inserting a new
element into a map does not invalidate iterators
that point to existing elements. Erasing an element from
a map also does not invalidate any iterators,
except, of course, for iterators that actually point to the element that is
being erased.

Set has the important property that inserting a new
element into a set does not invalidate iterators
that point to existing elements. Erasing an element from a set also does not
invalidate any iterators, except, of course, for iterators that actually point
to the element that is being erased.

Stack does not allow iteration
through its elements. This restriction is the only reason
for stack to exist at all. Note that
any Front
Insertion Sequence or Back
Insertion Sequence can be used as a stack; in the case
of vector, for example,
the stack operations are the member
functions back, push_back,
and pop_back. The only reason to use the container
adaptor stack instead is to make it clear that
you are performing only stack operations, and no other
operations.

Queue does not allow iteration through its
elements.This restriction is the only reason
for queue to exist at all. Any container that is
both a front
insertion sequence and a back
insertion sequence can be used as a queue; deque, for
example, has member
functions front,back, push_front, push_back, pop_front,
and pop_back The only reason to use the
container adaptor queue instead of the
container deque is to
make it clear that you are performing only queue operations, and no other
operations.

当然还有其他的，可以参阅相关文档。