linear time sortings for all categories

Question

I had this maybe stupid thought

since we have linear time sorting algorithms for constrained categroies like integers using counting sort, radix sort.

as in comp

Answer 1

No you cannot. if you have a piece of data represented by the bytes below:

11001100 00110011
(204)    (51)

If you were to sort these using something like radix sort you would get:

00110011 11001100
(51)     (204)

The only problem with this is that this is no longer the piece of data you wrote to the disk, it is a completely different piece of data that may not even mean anything at all(garbage).

Answer 2

Sure, although details vary from type to type. One simple example is IEEE-754 floating point values (both 32-bit and 64-bit), which can almost be sorted as though they were integers. (More specifically, they can be sorted as though they were sign-magnitude integers.) So a radix-sort would work fine.

For character strings, a not-uncommon technique when you have too many of them to fit in memory is to "bin" them by prefix, which is a variety of radix-sort.

For short bit-field values (like integers or, as above, floating point numbers), a left-to-right bit-at-a-time radix sort is really just a variant of quicksort, since it is basically just a way to find a plausible pivot. Unlike quicksort, it guarantees a finite recursion depth (32 in the case of 32-bit values). On the other hand, quicksort usually has a much smaller recursion depth, since log₂ of the dataset size is usually a lot less than 32.

The main advantage of quicksort is that you can write the algorithm (STL style) without knowing anything about the datatype being sorted at all, other than how to call a function to compare two values. The same cannot be said of radix-sort; it's a lot harder to make a generic version.

Edited to add one important point:

It's very common to overemphasize the difference between O(n) and O(n log n). For very large n, they are different. But for most real-world non-Google-sized problems, log n is a small integer. It wouldn't make sense to use an O(n) algorithm which takes 100n seconds when there is an O(n log n) algorithm which takes 2n log₂ n seconds, unless log n were greater than 50, which is to say that n were greater than 1,125,899,906,842,624.