选择排序与数组和链接列表之间的区别？

Question

Im wondering what is the logic behind selection sort using array with findmax, and linked list with findmin. Best and worst cases for both?

Answer 1

TL;DR

Selection sort is generically bad. Merge sort is generically good, but can be improved by std::sort for random access containers and member functions sort() for node based containers.

Selection sort scales quadratically

Consider the following generic version of selection_sort

template<class ForwardIt, class Compare = std::less<typename std::iterator_traits<ForwardIt>::value_type>>
void selection_sort(ForwardIt first, ForwardIt last, Compare cmp = Compare())
{
        for (auto it = first; it != last; ++it) {
                auto const selection = std::min_element(it, last, cmp);
                std::iter_swap(selection, it);
        }
}

On both std::array and std::list of length N , this has O(N^2) complexity: the outer loop processes all N elements, and the inner call to std::min_element is also of linear complexity, which gives overall quadratic scaling.

However, since comparison based sorting can be done as cheaply as O(N log N) , this is typically unacceptable scaling for large N . As mentioned by @EJP , one redeeming feature of selection sort is that although it does O(N^2) comparisons, it only does O(N) data swaps. However, for very large N , this advantage over most O(N log N) sorting algorithms, will ultimately be overwhelmed by the O(N^2) comparison cost.

Generic merge sort to the rescue?

Consider the following generic version of merge_sort

template<class BiDirIt, class Compare = std::less<typename std::iterator_traits<BiDirIt>::value_type>>
void merge_sort(BiDirIt first, BiDirIt last, Compare cmp = Compare())
{
        auto const N = std::distance(first, last);
        if (N < 2) return;
        auto middle = first + N / 2;
        merge_sort(first, middle, cmp);
        merge_sort(middle, last, cmp);
        std::inplace_merge(first, middle, last, cmp);
}

On both std::array and std::list of length N , this has O(N log N) complexity: the recursion depth is O(log N) (since the interval is being cut in half each time) and the call to std::inplace_merge is of linear complexity, which gives overall O(N log N) scaling.

However, pretty much any serious sorting algorithm contender will distinguish itself not significantly with number of comparisons but rather the associated overhead for accessing and placing the data. Such optimizations can only be done with more knowledge than for the generic version.

Random access containers can benefit from a hybrid algorithm

Containers with random access iterators can be more cheaply sorted using hybrid algorithms. The std::sort() and std::stable_sort functions from the Standard Library provide such hybrid algorithms of O(N log N) worst-case complexity. Typically they are implemented as IntroSort, which mixes the recursive random-pivot quick sort with heap sort and insertion sort, depending on the size of the various recursively sorted sub-ranges.

Node-based containers can benefit from a member function sort()

Comparison based sorting algorithms make heavy use of copying or swapping the underlying data pointed to by the iterators. For regular containers, swapping the underlying data is the best you can do. For node-based containers such as std::list or std::forward_list , you would prefer to splice : only rearranging the node pointers and avoid copying potentially large amounts of data. However, this requires knowledge about the connections between iterators.

This is the reason that std::list and std::forward_list both have a member function sort() : they have the same O(N log N) worst-case complexity, but take advantage of the node-based character of the container.