Quicksort, invented by C. A. R. Hoare, is the most common "industrial strength" sorting algorithm. As the name implies, it's supposed to be quick. It's not particularly easy to program or explain. It's also far less intuitive than any of selection sort, insertion sort, merge sort or bubble sort, all of which tend to be used by real people in the course of their everday lives.

Quicksort is often billed as being "efficient"; it is sometimes said to run in time O(n log n), but this is false for most naïve implementations.

Of course, you may want to redefine efficient for Quicksort to be the most efficient. Quicksort's worst case behaviour is quadratic (O(n^2)); for naïvely-coded versions, this often happens when data is already sorted or sorted in reverse. Since in some applications the list tends to be nearly sorted, this can be a very Bad Thing. Smart (or random) choice of the pivot element can make it O(n log n), but these are not nearly common enough (and can suffer high overheads). The worst cases are typically for nearly-ordered data (e.g. an already sorted array, or an array already sorted in reverse order, and arrays nearly in this situation). Quicksort's "introspective" variants improve on this, typically by detecting these situations and switching to some other sorting algorithm. This implementation is typical in the STL of C++.

Quicksort is considered "quick" because its average case behaviour (assuming all n! permutations are equally likely, or some similar limitations) is not only O(n log n), but also twice as fast as heap sort. And unlike merge sort, it's in-place (you don't need a second scratch array). So for some applications, it's really very good; unfortunately, not for all.

In C, Quicksort is accessed using the library routine qsort(). Because of its worst-case behaviour, unmodified Quicksort is not suitable for sorting in C++'s STL (there, O(n log n) worst case is required).

Another limitation is that Quicksort is not a stable sort: there's no (easy) way to cause it to preserve the ordering of elements which the comparison function deems equal without enlarging the array (which would, again, make it not be in-place!).

As always, who uses an algorithm must first determine its appropriateness for the problem.