Well normally if using depth-first traversal, we get O(n) time. However, if we find the minimum element first then call the successor() method n times, what time complexity will it be?
I think it may be O(n log n) because successor is O(log n) but that doesn't seem right. Can anyone offer any in-depth analysis here (probably involving some limit analysis)?
If parent pointers are present at each node, calling the successor method n times takes O(n) time. To see this observe that each edge in the tree gets visited at most twice (once from parent to child and once from child to the parent) by all the successor calls combined. Thus the total number of edges visited by all the successor calls is at most 2n. So the running time is O(n).
Now if parent pointers are not present, in every call we have to start from the root and search for the successor element by travelling through O(log n) nodes (if the tree is balanced). So the complexity becomes O(n log n).
Not quite a formal argument, but a fairly convincing one for O(n):
The successor function always takes the shortest path from the starting node to its successor. It either goes down or it goes up, but once it's started doing one it can't change to the other. Therefore it has to take the shortest path.
The successor function has to produce the same output as the depth-first method, so it has to visit the same nodes in the same order (i.e. the outputted ones, it doesn't have to go past the same ones, although it does).
The depth-first method also always takes the shortest path between each outputted node (in each step it goes either down or up, not both).
Therefore each method takes exactly the same path, and are in fact equivalent.
