std::sort 是否检查向量是否已经排序？

Question

I believe that the C++ standard for std::sort does not guarantee O(n) performance on a list that's already sorted. But still, I'm wondering whether to your knowledge any implementations of the STL (GCC, MSVC, etc) make the std::is_sorted check before executing the sort algorithm?

Asked another way, what performance can one expect (without guarantees, of course) from running std::sort on a sorted container?

Side note: I posted some benchmarks for GCC 4.5 with C++0x enabled on my blog. Here's the results:

Answer 1

Implementations are free to use any efficient sorting algorithm they want so this is highly implementation dependant

However I have seen a performance comparison of libstdc++ as used on linux and against libc++ the new C++ library developed by Apple/LLVM. Both these libraries are very efficient on sorted or reverse sorted data (much faster than on a random list) with the new library being considerable faster then the old and recognizing many more patterns.

To be certain you should consider doing your own benchmarks.

Answer 2

No . Also, it's not logical to have is_sorted() called for any STL implementation. Since, is_sorted() is available already as a stand-alone. And many users may not want to waste execution cycles unnecessarily to call that function when they already know that their container is not sorted.

STL also should be following the C++ philosophy: " pay per use ".

Answer 3

Wow? Did you have optimizations all the way cranked up?

the results of your code on my platform (note the values on the vertical axis).

Answer 4

I suggest you read this comparison of sorting algorithms , it is very well done and informative, it compares a number of sorting algorithms with each other and with GCC's implementation of std::sort. You will notice, in the charts on the given link, that the performance of std::sort for "almost sorted" and "almost reverse" are linear in the number of elements to sort, that is, O(n). So, no guarantee, but you can easily expect that an almost sorted list will be sorted in almost linear-time. But, of course, it does not do a is_sorted check, and even if it will sort a sorted array in linear-time, it won't be as fast as doing a is_sorted check and skipping the sorting altogether. It is your decision to determine if it is better to check before sorting or not.

Answer 5

The standard sanctions only std::sort implementations with complexity O(n log n):

Complexity: Approximately N log N (where N == last - first ) comparisons on the average.

See section 25.3.1.1 Sorting [lib.sort] (ISO/IEC 14882:2003(E)).

Thus, the set of allowed sorting functions is limited, and you are right that it does not guarantee linear complexity.

Ideal behavior for a sort is O(n), but this is not possible in the average case.

Of course the average case is not necessarily the exact case you have right now, so for corner cases, there's not much of a guarantee.

Answer 6

And why would any implementation do that check? What would it gain? -- Nothing in average. A good design rule is not to clutter implementation with optimizations for corner cases which make no difference in average. This example is similar to check for self-assignment. A simple answer: don't do it.

Answer 7

There's no guarantee that it'll check this. Some implementations will do it, others probably won't.

However, if you suspect that your input might already be sorted (or nearly sorted), std::stable_sort might be a better option.