Sorting Algorithms

DIRECTORY.md

@@ -0,0 +1,22 @@
+<!--- DO NOT EDIT: This file is automatically generated by `directory.nim` -->
+
+# The Algorithms — Nim: Directory Hierarchy
+
+## Dynamic Programming
+  * [Catalan Numbers](dynamic_programming/catalan_numbers.nim)
+  * [Viterbi](dynamic_programming/viterbi.nim)
+
+## Maths
+  * [Area](maths/area.nim)
+
+## Sorts
+  * [Bubble sort](sorts/bubble_sort.nim)
+  * [Insertion Sort](sorts/insertion_sort.nim)
+  * [Merge Sort](sorts/merge_sort.nim)
+  * [Quick Sort](sorts/quick_sort.nim)
+  * [Selection Sort](sorts/selection_sort.nim)
+  * [Shell Sort](sorts/shell_sort.nim)
+  * [Test sorting algorithms](sorts/testSort.nim)
+
+## Strings
+  * [Check Anagram](strings/check_anagram.nim)

sorts/bubble_sort.nim

@@ -0,0 +1,79 @@
+# Bubble sort
+#[
+Bubble sort, sometimes referred to as sinking sort, is a simple sorting algorithm that repeatedly steps through the input list element by element, comparing the current element with the one after it, swapping their values if needed. These passes through the list are repeated until no swaps had to be performed during a pass, meaning that the list has become fully sorted.
+# https://en.wikipedia.org/wiki/Bubble_sort
+]#
+
+func bubbleSort[T](l: var openArray[T]) =
+  let n = l.len
+  for i in countDown(n - 1, 1):
+    for j in 0 ..< i:
+      if l[j] > l[j+1]:
+        swap(l[j], l[j+1])
+
+
+func bubbleSortOpt1[T](l: var openArray[T]) =
+  let n = l.len
+  for i in countDown(n - 1, 1):
+    var flag: bool = true # Optimisation
+    for j in 0 ..< i:
+      if l[j] > l[j+1]:
+        flag = false
+        swap(l[j], l[j+1])
+    if flag: # We can return/break early
+      return
+
+func bubbleSortWhileLoop[T](l: var openArray[T]) =
+  ## The same optimization can be rewritten with
+  ## a while loop
+  let n = l.len
+  var swapped = true
+  while swapped:
+    swapped = false
+    for i in 1 ..< n:
+      if l[i-1] > l[i]:
+        swap l[i-1], l[i]
+        swapped = true
+
+func bubbleSortOpt2[T](l: var openArray[T]) =
+  ## The n-th pass finds the n-th largest element
+  ## So no need to look at the n last elements
+  ## during the (n+1)-th pass
+  var
+    n = l.len
+    swapped = true
+  while swapped:
+    swapped = false
+    for i in 1 ..< n:
+      if l[i-1] > l[i]:
+        swap l[i-1], l[i]
+        swapped = true
+    dec n
+
+when isMainModule:
+  import std/[unittest, random]
+  import ./testSort.nim
+  randomize()
+
+  suite "Insertion Sort":
+    test "Sort":
+      check testSort(bubbleSort[int])
+      check testSort(bubbleSortOpt1[int])
+      check testSort(bubbleSortWhileLoop[int])
+      check testSort(bubbleSortOpt2[int])
+    test "Sort with limit 10":
+      check testSort(bubbleSort[int], 15, 10)
+      check testSort(bubbleSortOpt1[int], 15, 10)
+      check testSort(bubbleSortWhileLoop[int], 15, 10)
+      check testSort(bubbleSortOpt2[int], 15, 10)
+    test "Sort with floating-point numbers":
+      check testSort(bubbleSort[float])
+      check testSort(bubbleSortOpt1[float])
+      check testSort(bubbleSortWhileLoop[float])
+      check testSort(bubbleSortOpt2[float])
+    test "Sort characters":
+      check testSort(bubbleSort[char])
+      check testSort(bubbleSortOpt1[char])
+      check testSort(bubbleSortWhileLoop[char])
+      check testSort(bubbleSortOpt2[char])
+

sorts/insertion_sort.nim

@@ -0,0 +1,52 @@
+## Insertion Sort
+#[
+This algorithm sorts a collection by comparing adjacent elements.
+When it finds that order is not respected, it moves the element compared
+backward until the order is correct.  It then goes back directly to the
+element's initial position resuming forward comparison.
+
+https://en.wikipedia.org/wiki/Insertion_sort
+]#
+
+import std/[random]
+
+func insertionSortAllSwaps[T](l: var openArray[T]) =
+  ## First implementation swaps elements until the right position is found
+  var i = 1
+  while i < len(l):
+    var
+      j = i
+    while j > 0 and l[j-1] > l[j]:
+      swap(l[j], l[j-1])
+      j = j - 1
+    i = i + 1
+
+func insertionSort[T](l: var openArray[T]) =
+  ## Sort your array similar to how you would sort your cards in your hand.
+  ## You take a card `key` and insert it in the right position in your hand one
+  ## at a time.
+  for j in 1 .. l.high:
+    var
+      key = l[j]
+      i = j - 1
+    while i >= 0 and l[i] > key:
+      l[i+1] = l[i]
+      i.dec
+    l[i+1] = key
+
+when isMainModule:
+  randomize()
+  import std/unittest
+  import ./testSort.nim
+
+  suite "Insertion Sort":
+    test "Sort":
+      check testSort(insertionSortAllSwaps[int])
+      check testSort(insertionSort[int])
+    test "Sort with limit 10":
+      check testSort(insertionSortAllSwaps[int], 15, 10)
+      check testSort(insertionSort[int], 15, 10)
+    test "Sort with floating-point numbers":
+      check testSort(insertionSort[float])
+    test "Sort characters":
+      check testSort(insertionSort[char])

sorts/merge_sort.nim

@@ -0,0 +1,62 @@
+# Merge Sort
+## Add Description
+{.push raises: [].}
+
+# TODO: proc mergeSort[T](l: var openArray[T]) =
+proc merge[T](list: var openArray[T], p, q, r: Natural) =
+  ## Merge two lists that have been sorted
+  ## Assumes all elements of `list` are less than
+  ## or equal to (T.high - 1) !
+  let
+    n1 = q - p + 1
+    n2 = r - q
+  var
+    L = newSeq[T](n1 + 1)
+    R = newSeq[T](n2 + 1)
+  for i in 0 ..< n1:
+    L[i] = list[p + i]
+  for j in 0 ..< n2:
+    R[j] = list[q + j + 1]
+  L[n1] = T.high
+  R[n2] = T.high
+  var
+    i = 0
+    j = 0
+  for k in p .. r:
+    if L[i] <= R[j]:
+      list[k] = L[i]
+      i.inc
+    else:
+      list[k] = R[j]
+      j.inc
+
+
+proc mergeSort[T](list: var openArray[T], first, last: Natural) =
+  ## Division step
+  ## We split the list in two equal parts and work
+  ## separately on each of them
+  if first < last:
+    let half = (first + last) div 2
+    mergeSort(list, first, half)
+    mergeSort(list, half + 1, last)
+    merge(list, first, half, last)
+
+
+func mergeSort[T](list: var openArray[T]) =
+  ## Top level procedure
+  ## O(n * log(n)) in average complexity where n = l.len
+  mergeSort(list, list.low, list.high)
+
+
+when isMainModule:
+  import std/[unittest, random]
+  import ./testSort
+  randomize()
+
+  suite "Merge Sort":
+    test "Integers":
+      check testSort mergeSort[int]
+    test "Float":
+      check testSort mergeSort[float]
+    test "Char":
+      check testSort mergeSort[char]

sorts/quick_sort.nim

@@ -0,0 +1,78 @@
+# Quick Sort
+## Add Description
+## TODO: Need an out of place version of the test
+## https://en.wikipedia.org/wiki/Shellsort
+## https://github.com/ringabout/data-structure-in-Nim/blob/master/sortingAlgorithms/quickSort.nim
+{.push raises: [].}
+
+import std/random
+
+proc quickSort[T](list: var openArray[T], lo: int, hi: int) =
+  ## Quick Sort chooses a pivot element against which other
+  ## elements will be compared
+  if lo >= hi:
+    return
+  # Pivot selection
+  # Historically, the first element
+  # let pivot = lo
+  # More performant: choose at random!!!
+  let pivot = rand(lo..hi)
+  var
+    i = lo + 1
+    j = hi
+
+  # We place the pivot element at the
+  # lowest position
+  swap(list[lo], list[pivot])
+  var running = true
+  while running:
+    while list[i] <= list[lo] and i < hi:
+      i += 1
+    while list[j] >= list[lo] and j > lo:
+      j -= 1
+    if i < j:
+      swap(list[i], list[j])
+    else:
+      running = false
+  swap(list[lo], list[j])
+
+  # Recursive calls
+  quicksort(list, lo, j - 1)
+  quicksort(list, j + 1, hi)
+
+
+proc quickSort*[T](list: var openArray[T]) =
+  ## Main function
+  quicksort(list, list.low, list.high)
+
+
+proc QuickSort[T](list: openArray[T]): seq[T] =
+  ## Second quick sort implementation, out-of-place but making a lot of copies
+  ## Easier to memorize
+  if len(list) == 0:
+      return @[]
+  var pivot = list[0]
+  var left: seq[T] = @[]
+  var right: seq[T] = @[]
+  for i in low(list)..high(list):
+      if list[i] < pivot:
+          left.add(list[i])
+      elif list[i] > pivot:
+          right.add(list[i])
+  result = QuickSort(left) &
+    pivot &
+    QuickSort(right)
+
+when isMainModule:
+  import std/[unittest]
+  import ./testSort
+  randomize()
+
+  suite "Quick Sort":
+    test "Integers":
+      check testSort quickSort[int]
+      # check testSort QuickSort[int]
+    test "Float":
+      check testSort quickSort[float]
+    test "Char":
+      check testSort quickSort[char]

sorts/selection_sort.nim

@@ -0,0 +1,29 @@
+# Selection Sort
+## Add description
+{.push raises: [].}
+
+func selectionSort[T](l: var openArray[T]) =
+  let n = l.len
+  for i in 0 .. n-2:
+    var
+      mini = l[i]
+      idx_min = i
+    for j in i ..< n:
+      if l[j] < mini:
+        mini = l[j]
+        idx_min = j
+    if idx_min != i:
+      swap(l[idx_min], l[i])
+
+when isMainModule:
+  import std/[unittest, random]
+  import ./testSort
+  randomize()
+
+  suite "Selection Sort":
+    test "Integers":
+      check testSort selectionSort[int]
+    test "Float":
+      check testSort selectionSort[float]
+    test "Char":
+      check testSort selectionSort[char]