## Sorting – An Introduction

If I recall correctly, sorting is a subject touched upon in the first year of a computer science (or computer information systems) student’s curriculum. The professor doesn’t go into too much depth with sorting, as there is much to get into. The professor wouldn’t normally focus on algorithm complexity (Big-O notation) or discussing data structures or recursion. Rather, the professor might merely mention sorting algorithms, name a few and probably show how bubble sort works.

If I were a professor, and I’m not so the world has that going for it, I’d reveal bubble sort to the class via pseudo-code. The class would get a homework assignment (keeping in mind this is a first year course). The assignment: convert the pseudo-code into a working program. But this isn’t about what I’d do if I were teaching a class, this is about helping you if you are ever presented with this assignment!

The following pseudo-code has been borrowed from wikipedia.

``````procedure bubbleSort( A : list of sortable items ) defined as:
do
swapped := false
for each i in 0 to length( A ) - 1 do:
if A[ i ] > A[ i + 1 ] then
swap( A[ i ], A[ i + 1 ] )
swapped := true
end if
end for
while swapped
end procedure
``````

That might look a little more complicated than you (or I) would like but with a little practice stuff like that turns into something that can be easily read.

This is what that pseudo-code turns into (and probably what you came here for in the first place) :

```int Bubblesort(int arr[], int length) {
int hold=0;
int i=0;
int keepSorting=0;
do {
keepSorting = 0;
for(i=0;i<length;i++) {
if (arr[i] > arr[i+1]) {
hold = arr[i+1];
arr[i+1] = arr[i];
arr[i] = hold;
keepSorting = 1;
}
}
} while (keepSorting);
return 1;
}```

That’s C code, not too different from the Java that a professor might use in a first year course. The boolean from the pseudo-code has been replaced with an integer. Bubblesort is fed an array as well as the length of the array. The variable hold is just a temporary variable to help in swapping side-by-side indexes in the array. Anyway, that will get your homework done.

Two other very common sorting algorithms are Insertion sort and Quick sort. You’ll learn a little more about them in the next article on sorting.

One more thing. Here’s a quick comparison of the three sorting algorithms and how long it takes each of them to sort a bunch of unsorted numbers.

## Winning Numbers

The lottery simulation is in a very usable state. I’d just like to make a note before I forget, it was written and implemented in Linux. I use Ubuntu 7.10 (and am very excited at the release of Ubuntu 8.04 in two days). The required programs, should you choose to download and play with the code, are as follows:

1. Scilab for crunching the data (ie, calculating averages).
2. Gnuplot for plotting the data and saving them as images (where Scilab falls short).

You may also need to “sudo apt-get install build-essential” if you want to alter and compile the source, particularly if you’re using Ubuntu. For some reason it wasn’t included with the default Ubuntu 7.10 install.

I’m continuing to generate data and eventually (it takes a long time) I’ll have 10000 to 50000 points of data for every combination of n choose k between 2 to 49.

### Coming up next…

I’m playing with sorting algorithms. First up, bubble sort. So keep an eye out on the science page.

Staypressed theme by Themocracy