Posts tagged: bubblesort

Sorting – More Depth! (and Big-O)

I’m going to get to the point. I’m writing this so you don’t have to spend a whole lot of time scouring the ‘net in search of a solution to your homework assignment.

In later years (2nd, 3rd, 4th) professors get heavy on the subject of efficiency and really analyze algorithms (thus, courses aptly named algorithm analysis). This is where “Big-O” notation comes in to play.

If you’re anything like me, that didn’t make too much sense at the start. Even now I can’t think of when I might actually compare the runtime of an algorithm to the graph created from n2 or n log n. However, what algorithm analysis has given me is the understanding that programs that take a really long time to run can usually be improved upon. And if there’s an algorithm that takes a long time to run that hasn’t yet been improved upon then there is often a prize for the person who can improve upon it (or who gets lucky).

With that being said, let’s look at those three sorting algorithms again.

Bubble Sort is said to have a runtime of O(n2) at worst. What does that mean to you? Well, it means that this sorting algorithm sucks for every day use. But we’re human, and that means we can learn from this mistake. Don’t use bubble sort, but maybe give your professor a hard time about it. Squeeze it into another program somewhere, as a joke. No, don’t listen to me.

Bubble sort, incremental

Insertion Sort is another example of a sorting algorithm with a worst-case runtime of O(n2). Though it has the same runtime complexity as Bubble Sort, don’t be fooled into thinking that Insertion Sort is always just as slow. Insertion Sort is still worlds more efficient at sorting than Bubble Sort.

Insertion Sort, incremental

See that!? Insertion Sort takes care of 150,000 unsorted values in 1/5 the time it took Bubble Sort to sort the same values. But there is still a quicker way to sort…

Quick Sort is the last algorithm in the scope of this article. The algorithm is just that, it’s quick. Quick Sort has an average runtime complexity of O(n log n) which is a huuuge improvement over Insertion and Bubble Sort.

Quick sort, incremental

And in case you are curious, this is what n2 looks like when graphed.

And what n log n looks like when graphed.

And when the two are compared you can see a massive difference:

If you feel so inclined to play around with sorting algorithms, the source code for my sorting demo can be found here or on the files page.

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.

Sort Time Comparison

Staypressed theme by Themocracy