So, even before I get to the what the algorithm does (which is quite interesting on its own, even before you find out how it accomplishes that), the very first intriguing part is its name. It’s officially referred to as the Blum-Floyd-Pratt-Rivest-Tarjan Algorithm. Is your mouth watering yet? I thought so.^{1} However, CLRS refers to it as the Select Algorithm (see section 9.3), so that’s what I’m going to call it. If you have an unsorted array of n items, it’s a worst-case O(n) algorithm for finding the i^{th} largest item (often the median, since that’s a commonly used statistic). Here’s how the algorithm works:

- Put all the elements of the input into groups of 5 (with one group at the very end that could have less than 5 elements, of course). Find the median of each group.
- Recursively use the Select algorithm to find the median of all the group-of-5 medians from step 1. Call this median of medians
*M*.
- Take all the items from the input and partition them into the group of items less than
*M* and the group of items bigger than *M*.
- If
*M* is the i^{th} biggest, that’s the answer, and we’re done. If it’s not, you know which partition contains the i^{th} biggest item, and you can recursively call Select on that group (with a different i if the group it’s in is the group of items smaller than *M*).

To give an example of that last statement, suppose we’re looking for the 65th biggest number from a group of 100 numbers, and we find that *M* is the 53rd largest. There are 47 numbers smaller than *M*, and when we recurse, we’ll now be looking for the 12th largest element of that set of 47. If instead *M* had been the 68th largest number, in our recursive step we’d look at the 67 numbers larger than *M* and continue to look for the 65th largest one.

Now, I claimed the running time is linear, and I’d better back up that claim. The trick is to consider how many items get thrown out in that last step. Half the group-of-5 medians are larger than *M*, and half are smaller. Without loss of generality, suppose the i^{th} largest item is in the group that is larger than *M*. Now, not only do we know that we can henceforth ignore the half of the group-of-5 medians smaller than *M*, for each of those medians we can ignore the two items in the group of 5 that were smaller than that median. In other words, we can eliminate at least 3/10 of the elements we were searching over (we can eleminate 3/5 of the items in the groups whose median is smaller than *M*, and half of all the groups fit this category). Sure, I’m eliding an additive constant for the items in the group with *M* itself (not to mention the items in that last small group at the end when n is not a multiple of 5), but that’s not going to affect the asymptotic running time.

So now we can build the recurrence relation at work here. If T(n) is the amount of work done to perform Select on n items, we have

T(n) = O(n) + T(n/5) + T(7n/10)

That is to say, we do O(n) work in steps 1 and 3, we do T(n/5) work in step 2, and we do T(7n/10) work in step 4 because we know at least 3/10 of the elements are in the wrong partition. I’ll leave it as an exercise to the reader to draw out the recursion tree and find the actual amount of work done, but I assure you T(n) is in O(n).

The crazy part here is that magic number 5: If you do this with 3 items per group, the running time is O(n log n). If you do it with more than 5, the running time is still linear, but slower (you spend more time in step 1 finding all the initial medians). The optimal number of items per group really is 5. Nifty!

[1] For those of you not in the know, these are all really famous algorithms names. Blum is the co-inventor of the CAPTCHA. Floyd is from the Floyd-Warshall all-pairs shortest-paths algorithm, which is a staple in introductory algorithms courses. Pratt is from the Knuth-Morris-Pratt string matching algorithm, which was groundbreaking when it was new but is nearly obsolete now. Rivest is the R in RSA encryption, one of the most widely used encryption schemes around. Tarjan is the co-creator of splay trees, a kind of self-balancing tree with the handy property that commonly accessed items float to the top. Blum, Floyd, Rivest, and Tarjan have each won the Turing Award, which is like the Nobel Prize of computer science.