I believe, one of the most interesting topics, which includes opportunities for both to learn more about algorithms theory and see an example of the practical implementation, is the topic of NumPy sorting. ​ ​ This may sound a little nerdy, but let me provide a short survey of available options to prove the suggestion above.​ https://vovenur.medium.com/numpy-sorting-and-dancing-and-memes-bf3ce0fe7c3​

1. NumPy sorting
(and dancing and memes):
a short review for students
Vladimir Fadeev
https://vovenur.medium.com/numpy-sorting-and-dancing-and-memes-bf3ce0fe7c3

2. Preface
I believe, one of the most interesting topics, which includes opportunities for both to learn
more about algorithms theory and see an example of the practical implementation, is the
topic of NumPy sorting.
This may sound a little nerdy, but let me provide a short survey of available options to
prove the suggestion above.

3. Structure: what can you find there?
• Short theoretical descriptions:
 The review should be meaningful.
• Dancing illustrations by AlgoRythmics project
 The survey should be demonstrative;
 and I’m crazy about things that include both art and education!
• Several memes:
 Just for fun!

4. numpy.sort()
So, what sorting algorithms are provided by NumPy? Of course, we are going to the
documentation page:
numpy.sort() method (version 1.19.0)
• heapsort
• mergesort
• stable (since version 1.15.0)
• quicksort (by default)
Hm, not so much. Let’s consider them step by step.

5. heapsort
The heapsort algorithm directly
relates to binary heaps (and this
defines the name of the algorithm).
Overall asymptotic complexity
is O(N*log2(N)).
An example of heapsort using binary
min-heap is described in
the heapq python module
documentation.
Let’s dance?

6. mergesort
At the first blush, this is
classical mergesort the main idea of which
can be described via the ancient idiom
“divide and conquer”:
o an array to be sorted should be split into
two parts of approximately the same size;
o each of the resulting parts is sorted
separately, for example, by the same
algorithm;
o two ordered arrays of half-size are
concatenated into one. Credits: ITMO University

7. Several important
facts about mergesort
• asymptotic complexity is the
same for the best, the worst and
average cases: O(N*log2(N));
• requires O(N) additional memory
for sorting of arrays (but this fact
doesn’t play a role in case of
linked lists);
• optimally works with data
structures which provide
sequential access to elements
(e.g. linked lists);
• stable.

8. However, what
do we read in the
NumPy
documentation:
New in version 1.17.0.
Timsort is added for better performance on already
or nearly sorted data. On random data timsort is
almost identical to mergesort. It is now used for
stable sort while quicksort is still the default sort if
none is chosen. For timsort details, refer to CPython
listsort.txt. ‘mergesort’ and ‘stable’ are mapped to
radix sort for integer data types. Radix sort is an O(n)
sort instead of O(n log n).

9. That is to say 1. mergesort and stable options
mean the same in the
numpy.sort();
2. a hybrid type of sorting
(Timsort algorithm) is used
instead of
“pure” mergesort (like in
method sort() and
function sorted() in CPython);
3. if elements of the array are
integers (int), O(N) radix sort
will be used.

10. So, we can make
intermediate conclusion
that the name mergesort in
NumPy is rather kind of
legacy.

11. quicksort
Let’s start from basics. In short, the
classical quicksort:
• selects a pivot element;
• devices the array into three groups:
“less”, “larger” and “equal” (than/to
pivot element);
• applies itself to the resulting groups
recursively.

12. Several facts about quicksort
• average asymptotic complexity is O(N*log2(N));
• the worst asymptotic complexity is O(N²);
• requires а relatively small amount of the additional memory (O(log2(N)));
• a part of the standard library of the C language (qsort());
• not stable.

13. But! In fact, now this
option means another
sorting algorithm too.
"New in version 1.12.0.
quicksort has been changed to introsort.
When sorting does not make enough
progress it switches to heapsort. This
implementation makes quicksort
O(n*log(n)) in the worst case."
In other words, the quicksort option means
a hybrid sorting algorithm which uses
either the quicksort or the heapsort
depending on the circumstances (usually,
it depends on the depth of the quicksort
recursion).
Yep, the second legacy name.

14. Table to
summarize
Name of the option Used algorithm
heapsort heapsort
mergesort timsort or radix sort
stable timsort or radix sort
quicksort introsort

15. Conclusion
1. Theory: reading of the documentation about
NumPy sorting inspires to learn more about
both classical and hybrid sorting algorithms.
2. Practice: reading of the documentation about
NumPy sorting allows tracing how simple
sorting methods become more complicated,
develop into hybrid ones and find their
application, including in the framework of
modern tools used by engineers and the
scientific community
(note, pandas.DataFrame.sort_values method
uses the same algorithms).
Have a nice day!

16. Literature
• Stephens, Rod. Essential Algorithms: A Practical Approach to Computer Algorithms. John
Wiley & Sons, 2013.
• Sedgwick, R., 1998. Algorithms in C++, Parts 1–4: Fundamentals, Data Structure, Sorting,
Searching.

17. Links for the visualization
• SORTING.at
• Sorting Algorithms Animations
• Min Heap sort

18. Do you know that in
Russian the second variant
of the heapsort’s name is
the “pyramid sorting”?