# Which sorting algorithm is used by STL's list::sort()?

### Question

I have a list of random integers. I'm wondering which algorithm is used by the `list::sort()` method. E.g. in the following code:

``````list<int> mylist;

// ..insert a million values

mylist.sort();
``````

1
36
4/22/2018 4:04:32 PM

The standard doesn't require a particular algorithm, only that it must be stable, and that it complete the sort using approximately N lg N comparisons. That allows, for example, a merge-sort or a linked-list version of a quick sort (contrary to popular belief, quick sort isn't necessarily unstable, even though the most common implementation for arrays is).

With that proviso, the short answer is that in most current standard libraries, `std::sort` is implemented as a intro-sort (introspective sort), which is basically a Quicksort that keeps track of its recursion depth, and will switch to a Heapsort (usually slower but guaranteed O(n log n) complexity) if the Quicksort is using too deep of recursion. Introsort was invented relatively recently though (late 1990's). Older standard libraries typically used a Quicksort instead.

`stable_sort` exists because for sorting array-like containers, most of the fastest sorting algorithms are unstable, so the standard includes both `std::sort` (fast but not necessarily stable) and `std::stable_sort` (stable but often somewhat slower).

Both of those, however, normally expect random-access iterators, and will work poorly (if at all) with something like a linked list. To get decent performance for linked lists, the standard includes `list::sort`. For a linked list, however, there's not really any such trade-off -- it's pretty easy to implement a merge-sort that's both stable and (about) as fast as anything else. As such, they just required one `sort` member function that's required to be stable.

45
4/28/2016 8:46:01 PM

It's completely implementation defined. The only thing the standard says about it is that it's complexity is O(n lg n), and that the sort is stable. That is, relative order of equal elements is guaranteed to not change after sorting.

`std::list`'s sort member function is usually implemented using some form of merge sort, because merge sort is stable, and merges are really really cheap when you are working with linked lists.

Hope that helps :)