A lot of people think that HeapSort and QuickSort are "THE BEST" sorting algorthms. But they aren't. "THE BEST" is a juvenile conceit. Every algorithm has its best and worst cases. You can apply a compression algorithm to some data and that algorithm would actually result in a larger amount of data that what you started with - take a look next time you use a command-line ZIP program and you'll see that it tries different algorithms to see which one works best for each file.
Heap and Quick sorts are optimal for large amounts of completely random data. They will do abominably when applied to data that is entirely or nearly entirely ordered and they carry so much overhead that if the data set is small enough they won't be any faster than a dumber sort.
My classic example was an old mainframe app I used to be responsible for. It was the central control and distribution point for every form of output from the shop's application systems and it ran hundreds of times a day, so the more efficient it was, the better. This particular system got a whole bunch of items in its input that were mostly, but not completely in order - there was a knot in the data where some of the high-key items were produced about 75% through the data stream being fed to my app.
That's a worst-case scenario for Heap and Quick sorts. It's also a bad case for the simple Bubble sort, since the out-of-sequence data was deep enough into the set that a lot of bubble passes would be required.
The optimal sort for that particular data set was the Shell-Metzner sort. Like the Bubble sort, it works well on pre-ordered data, but has the advantage that the out-of-sequence data can "leapfrog" up the chain in a binary fashion.
There was another advantage unique to the times and conditions. Back then you couldn't just grab a sort algorithm and plug it in. You had commercial sorts, but they were large stand-alone apps, not suitable for trivial inclusion in other programs. And while COBOL had limited sorting support, the systems I worked on weren't suitable for coding in COBOL; I was constrained to use Assembly Language (stuff like C wasn't generally available for mainframes back then). A Bubble Sort was about 1 page of code and maybe a day to implement, so our assembly language apps typically did bubble sorts. A Shell sort ran me about 3 pages of code and 2 days work - a worthwhile investment. Anything more sophisticated would have probably run 5 pages minimum and a week of labor. And while the "Git 'R Dun!"
philosophy wasn't an overriding concern back then when machines were more expensive than humans, I had enough other things to do that I wasn't of a mind to add extra work if I could avoid it!