Question

I have a list of about 200 integers whose values are between 1 and 5.

I want to get into learning about sorting algorithms and knowing where to apply each because at the moment I use bubble-sort for everything which I’ve been told is a terrible way to do things.

What would be the fastest sorting algorithm for this integer sorting?

EDIT: It turns out that because I know the numbers are 1 to 5 then I can use a bucket sort (?) algorithm which if I’m not mistaken – and I definitely could be – means that for each integer of value 1, I put it in the 1 group, value 2 I put it in the 2 group etc, then concatenate the groups at the end. This seems like a simple and efficient way to do it.

However since this is (currently) a learning excercise for me I am going to remove the 1 – 5 limitation and try to implement bubble-sort and merge-sort then compare the two to see which is faster.

Thanks for your help!

Answer 1

… which I’ve been told is a terrible way to do things.

First off, don’t accept as gospel anything you hear from random bods on the internet (even me).

Bubble sort is fine under certain conditions, such as when the data is already mostly sorted, or the item count is relatively small (such as 200) ^(a), or you have no sort functionality built into the language and you’re on a tight deadline where lack of performance will annoy the customer but lack of functionality will get you fired 🙂

This bias against bubble sort is similar to the “only one exit point from a function” and “no goto” rules. You should understand the reasoning behind them so that you know when the rules can be ignored safely.

Anyway, on to the question proper. An efficient way for your specific case is to just count the items then output them, something like:

dim count[1..5] = {0, 0, 0, 0, 0};
for each item in list:
    count[item] = count[item] + 1
for val in 1..5:
    for quant in 1..count[val]:
        output val

That’s an O(n) time and O(1) space solution and you won’t find a more efficient big-O for a generalised sort routine – it’s only possible in this case because of the extra information you have about the data (limited to the values 1 through 5).

If you wanted to examine all the different sort algorithms, the Wikipedia Sorting Algorithm page is a useful starting point, including the major algorithms and their properties.

---

^(a) As an aside, the following code (using worst case data for bubble sort), when run under CygWin on a not-very-powerful IBM T60 (2GHz dual core) laptop, completes in, on average, 0.157 seconds (5 samples: 0.150, 0.125, 0.192, 0.199, 0.115).

I wouldn’t use it for sorting a million items (everyone knows bubble sort scales poorly) but 200 should be fine in most cases:

#include <stdio.h>

#define COUNT 200
int main (void) {
    int i, swapped, tmp, item[COUNT];

    // Set up worst case (reverse order) data.

    for (i = 0; i < COUNT; i++)
        item[i] = 200 - i;

    // Slightly optimised bubble sort.

    swapped = 1;
    while (swapped) {
        swapped = 0;
        for (i = 1; i < COUNT; i++) {
            if (item[i-1] > item[i]) {
                tmp = item[i-1];
                item[i-1] = item[i];
                item[i] = tmp;
                swapped = 1;
            }
        }
    }

    // for (i = 0; i < COUNT; i++)
    //     printf ("%d ", item[i]);
    // putchar ('\n');

    return 0;
}