# PHP and MySQL Natural Sort

## Use Case

Let’s say we have an array of data represented by some text followed by a number. Just like the movies from a movie series like “Mission Impossible” or “Pirates of the Carribean”. We know that they are often followed by the consecutive number of the episode.

```Mission: Impossible 1 Mission: Impossible 2 Mission: Impossible 3 ...```

Since we have no more than three or four episodes we can easily sort the array if it’s not sorted initially.

```\$a = array('Mission: Impossible 2', 'Mission: Impossible 3', 'Mission: Impossible 1');   sort(\$a);   // Mission: Impossible 1 // Mission: Impossible 2 // Mission: Impossible 3 print_r(\$a);```

However in some cases we can have more than 10 episodes. Then we can meet a problem while sorting the array above.

```\$a = array('Episode 1', 'Episode 2', 'Episode 11', 'Episode 112');   sort(\$a);   // Episode 1 // Episode 11 // Episode 112 // Episode 2 print_r(\$a);```

Now because this is by default an alphabetical sort order we get an array that isn’t sorted to our human undestanding.

The question is how to overcome this problem?
Continue reading PHP and MySQL Natural Sort

Radix sort is an elegant and fast integer-sorting algorithm as explained in the following cheatsheet. Please click on the image bellow to download the cheatsheet on PDF!

# Computer Algorithms: Bubble Sort

## Overview

It’s weird that bubble sort is the most famous sorting algorithm in practice since it is one of the worst approaches for data sorting. Why is bubble sort so famous? Perhaps because of its exotic name or because it is so easy to implement. First let’s take a look on its nature.

Bubble sort consists of comparing each pair of adjacent items. Then one of those two items is considered smaller (lighter) and if the lighter element is on the right side of its neighbour, they swap places. Thus the lightest element bubbles to the surface and at the end of each iteration it appears on the top. I’ll try to explain this simple principle with some pictures.

### 1. Each two adjacent elements are compared

Here “2” appears to be less than “4”, so it is considered lighter and it continues to bubble to the surface (the front of the array).
Continue reading Computer Algorithms: Bubble Sort

# Friday Algorithms: JavaScript Bubble Sort

## Bubble Sort

This is one of the most slowest algorithms for sorting, but it’s extremely well known because of its easy to implement nature. However as I wrote past Fridays there are lots of sorting algorithms which are really fast, like the quicksort or mergesort. In the case of bubble sort the nature of the algorithm is described in its name. The smaller element goes to the top (beginning) of the array as a bubble goes to the top of the water.

There is a cool animation showing how bubble sort works in compare to the quick sort and you can practically see how slow is bubble sort because of all the comparing.

QuickSort vs. BubbleSort

## Pseudo Code

Actually what I’d like to show you is how you can move from pseudo code to code in practice. Here’s the pseudo code from Wikipedia.

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

## JavaScript Source

```var a = [34, 203, 3, 746, 200, 984, 198, 764, 9];   function bubbleSort(a) { var swapped; do { swapped = false; for (var i=0; i < a.length-1; i++) { if (a[i] > a[i+1]) { var temp = a[i]; a[i] = a[i+1]; a[i+1] = temp; swapped = true; } } } while (swapped); }   bubbleSort(a); console.log(a);```

As a result you’ve a sorted array!