Every couple of years it can be fun to revisit the basics. Given that I’m back in interview mode, I figured now was a good time to rewrite some of those sorting algorithms from sophomore year… in Go of course. You can find all the code in this post on GitHub under the sort directory here. The benchmark results can be reproduced by running the “gotest -v -bench=.” command from within the sort package directory. All of the results stem from the same input data and each algorithm is run with both sorted and unsorted data.

The easiest to implement and the most widely used sorting algorithm for small sets of data is Selection sort. It uses two loops and checks each entry for a suitable replacement.

package sort
func swap(a []int, x int, y int){
var temp = a[x]
a[x] = a[y]
a[y] = temp
}
func SelectionSort(a []int) {
for i, _ := range a {
for j := i + 1; j < len(a); j++ {
if a[j] < a[i] {
swap(a, i, j)
}
}
}
}

The results show that Selection sort performs substantially faster if the array is already sorted. The worst-case, average-case, and best-case running time are all quadratic which makes it a bad choice for large quantities of data.

Selection Sort:** O(n^2)**

sort.BenchmarkSelectionSort_Unsorted 500 4792526 ns/op

sort.BenchmarkSelectionSort_Sorted 2000 1026659 ns/op

Another simple and natural sorting algorithm is Insertion sort. Similar to Selection sort it uses two loops to sort but offers a much better best-case running time. When the data set is nearly sorted it can execute in linear time as the second loop only executes if the value to the left is greater then itself.

func InsertionSort(a []int) {
for j := 1; j < len(a); j++ {
var key = a[j]
var i = j-1
for i >= 0 && a[i] > key {
a[i+1] = a[i]
i</span> = i -1
}
a[i+1] = key
}
}

The results show a substantial increase over Selection sort above. Both the worst-case and average-case running times are quadratic, but the best-case is linear. Notice the benchmark time for an already sorted array.

Insertion Sort: **O(n^2)**

sort.BenchmarkInsertionSort_Unsorted 1000 1835507 ns/op

sort.BenchmarkInsertionSort_Sorted 200000 8698 ns/op

Quadratic sorting time just isn’t acceptable for large sets of data. To help achieve a linear sorting time several divide-and-conquer recursive algorithms exists. Quicksort is the most common, although slightly more complicated than the above quadratic algorithms. It offers a substantial performance increase when dealing with large unsorted data sets. A complete breakdown of Quicksort is outside the scope of this post, if necessary you can study it more in depth here. Basically, Quicksort recursively sorts the data set by continually dividing the set into subsets centered around a pivot point (in this case a[r] in partition() below).

func partition(a []int, p int, r int) int {
var x = a[r]
var i = p - 1
for j := p; j <= r - 1; j++ {
if a[j] <= x {
i = i + 1
swap(a,i,j)
}
}
swap(a,i+1,r)
return i + 1
}
func quickSort(a []int, p int, r int) {
if p < r {
var q = partition(a, p, r)
quickSort(a,p,q-1)
quickSort(a,q+1,r)
}
}
func QuickSort(a []int) {
quickSort(a, 0, len(a)-1)
}

The worst-case running time is quadratic and happens when the array is already sorted. The results show a slower worst-case sorting time then Selection sort, making Quicksort a bad choice if the data set is already or nearly sorted. However, the average-case and best-case running times are linear making it a good all around sorting algorithm for large data sets.

Quicksort: **O(n log n)**

sort.BenchmarkQuickSort_Unsorted 500 2836278 ns/op

sort.BenchmarkQuickSort_Sorted 500 6091908 ns/op

Despite the obvious benefits of Quicksort, it’s often a poor choice for applications requiring a consistent predictable sort time (such as in real-time embedded systems). This is because it is often not possible to know how sorted the data set is at any given time, meaning that it’s difficult to predict if the sort operation will be O(n^2) or O(n log n). In these scenarios using the Heap sort algorithm is a better choice. Although at first it appears more complicated then Quicksort, it offers both a worst-case and average-case O(n log n) sort time.

A heap is a binary tree where the entries of the nodes can be compared with the less-than operator, meaning that the value of a node is never less then its children and each level of the tree is complete with non-complete leaves. The deepest level are as far left as possible. For a complete description of Heap sort look here.

// in Python these would be a lambda and C++ would be an inline
func parent(i int) int {
return ((i-1)/2)
}
func left(i int) int {
return ((2*i)+1)
}
func right(i int) int {
return ((2*i)+2)
}
func MaxHeapify(a []int, i int, size int) {
var left = left(i)
var right = right(i)
var largest = i
if left a[i] {
largest = left
}
if right a[largest] {
largest = right
}
if largest != i {
swap(a,i,largest)
MaxHeapify(a, largest, size)
}
}
func BuildMaxHeap(a []int) {
for i:=(len(a)/2); i >= 0; i-- {
MaxHeapify(a,i,len(a))
}
}
func HeapSort(a []int) {
BuildMaxHeap(a)
var size = len(a)
for i:=len(a)-1; i >=1; i-- {
swap(a,0,i)
size = size - 1
MaxHeapify(a,0, size)
}
}

Heap Sort: **O(n log n)**

sort.BenchmarkHeapSort_Unsorted 10000 233454 ns/op

sort.BenchmarkHeapSort_Sorted 10000 262941 ns/op