在 C++ 的嵌套 for 循环中迭代 map 的时间复杂度是多少？

Question

I know the map in C++ is a balanced binary search tree. But, when I iterate through the map in nested for loop, I wonder what the time complexity would be

for (auto x : mp) {
        for (auto y : mp) {
              //
              //
        }
 }

Answer 1

The C++ standard requires that forward iterators are amortized constant time, so each of your loops are Theta(n). Because they're nested, the complexity will be Theta(n^2).

If you have a (balanced or not) binary search tree with parent links, then incrementing an iterator is O(log n) in the worst case, but O(1) amortized over the whole tree iteration, because each node in the traversal is visited at most 3 times (once when you first encounter the node, once after traversing the left subtree below it, and once after traversing the right subtree below it).

Answer 2

Depends on the implementation of the iterator of mp . Every for-loop creates one iterator instance, but in the background they could rely on the same objects.

In the most and simple cases, it will be outer over inner loop, so easily O(n²).

In a strange case it might be O(n) but then the implementation of the iterator is messed by logic (maybe someone can comment a good reason)

And in a even stranger case it doesn't determine, when the first iterator is disturbed by the creation of the next one. The main reason there would be lazy static loop variables or static pointer used in the iterators class.

And to your special case when the elements are only available as a binary tree, think about how an iterator there will work: next() will be either left, right or none(=backwards up), so a fixed search length with the maximum recursive tree length. Balanced means there is in general a set of l/r and at the tip log(n) elements of none, regarding this as a constant factor meaning n*=nx log(n). So the expected answer is O( (n*log(n))² ) = O( n² * log(n)² ) and regarding what outruns the Landau is the first part, so again O(n²) when it comes to the relevant number of elements.

Even then it may be performance wise to check the inner structure of map and create an iterator based on the keys, not on map.get().