Create Lua sorting algorithms.

Author: Shawn Bragdon

sortingAlgo/bubbleSort/bubbleSort.lua

@@ -0,0 +1,14 @@
+local function bubbleSort(t)
+    local n = #t
+    for i = 1, n do
+        for j = 1, n - i do
+            if t[j] > t[j + 1] then
+                t[j], t[j + 1] = t[j + 1], t[j]
+            end
+        end
+    end
+end
+
+local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
+bubbleSort(t)
+print(table.concat(t, ", "))

sortingAlgo/bucketsort/bucketSort.lua

@@ -0,0 +1,27 @@
+local function bucketSort(t)
+    local n = #t
+    local buckets = {}
+    for i = 1, n do
+        local bucket = math.floor(n * t[i])
+        buckets[bucket] = buckets[bucket] or {}
+        table.insert(buckets[bucket], t[i])
+    end
+    for i = 1, n do
+        if buckets[i] then
+            table.sort(buckets[i])
+        end
+    end
+    local k = 1
+    for i = 1, n do
+        if buckets[i] then
+            for j = 1, #buckets[i] do
+                t[k] = buckets[i][j]
+                k = k + 1
+            end
+        end
+    end
+end
+
+local t = { 0.3, 0.2, 0.1, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1 }
+bucketSort(t)
+print(table.concat(t, ", "))

sortingAlgo/cocktailSort/cocktailSort.lua

@@ -0,0 +1,31 @@
+local function cocktailSort(t)
+    local n = #t
+    local swapped = true
+    local start = 1
+    local end_ = n - 1
+    while swapped do
+        swapped = false
+        for i = start, end_ do
+            if t[i] > t[i + 1] then
+                t[i], t[i + 1] = t[i + 1], t[i]
+                swapped = true
+            end
+        end
+        if not swapped then
+            break
+        end
+        swapped = false
+        end_ = end_ - 1
+        for i = end_, start, -1 do
+            if t[i] < t[i - 1] then
+                t[i], t[i - 1] = t[i - 1], t[i]
+                swapped = true
+            end
+        end
+        start = start + 1
+    end
+end
+
+local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
+cocktailSort(t)
+print(table.concat(t, ", "))

sortingAlgo/combSort/combSort.lua

@@ -0,0 +1,23 @@
+local function combSort(t)
+    local n = #t
+    local gap = n
+    local shrink = 1.3
+    local swapped = true
+    while gap > 1 or swapped do
+        gap = math.floor(gap / shrink)
+        if gap < 1 then
+            gap = 1
+        end
+        swapped = false
+        for i = 1, n - gap do
+            if t[i] > t[i + gap] then
+                t[i], t[i + gap] = t[i + gap], t[i]
+                swapped = true
+            end
+        end
+    end
+end
+
+local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
+combSort(t)
+print(table.concat(t, ", "))

sortingAlgo/countingSort/countingSort.lua

@@ -0,0 +1,20 @@
+local function countingSort(t)
+    local n = #t
+    local counts = {}
+    for i = 1, n do
+        counts[t[i]] = (counts[t[i]] or 0) + 1
+    end
+    local k = 1
+    for i = 1, n do
+        if counts[i] then
+            for j = 1, counts[i] do
+                t[k] = i
+                k = k + 1
+            end
+        end
+    end
+end
+
+local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
+countingSort(t)
+print(table.concat(t, ", "))

sortingAlgo/cycleSort/cycleSort.lua

@@ -0,0 +1,36 @@
+local function cycleSort(t)
+    local n = #t
+    for i = 1, n do
+        local item = t[i]
+        local pos = i
+        for j = i + 1, n do
+            if t[j] < item then
+                pos = pos + 1
+            end
+        end
+        if pos == i then
+            goto continue
+        end
+        while item == t[pos] do
+            pos = pos + 1
+        end
+        t[pos], item = item, t[pos]
+        ::continue::
+        while pos ~= i do
+            pos = i
+            for j = i + 1, n do
+                if t[j] < item then
+                    pos = pos + 1
+                end
+            end
+            while item == t[pos] do
+                pos = pos + 1
+            end
+            t[pos], item = item, t[pos]
+        end
+    end
+end
+
+local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
+cycleSort(t)
+print(table.concat(t, ", "))

sortingAlgo/heapSort/heapSort.lua

@@ -0,0 +1,29 @@
+local function heapSort(t)
+    local n = #t
+    local function heapify(t, n, i)
+        local largest = i
+        local l = 2 * i
+        local r = 2 * i + 1
+        if l <= n and t[l] > t[largest] then
+            largest = l
+        end
+        if r <= n and t[r] > t[largest] then
+            largest = r
+        end
+        if largest ~= i then
+            t[i], t[largest] = t[largest], t[i]
+            heapify(t, n, largest)
+        end
+    end
+    for i = math.floor(n / 2), 1, -1 do
+        heapify(t, n, i)
+    end
+    for i = n, 2, -1 do
+        t[1], t[i] = t[i], t[1]
+        heapify(t, i - 1, 1)
+    end
+end
+
+local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
+heapSort(t)
+print(table.concat(t, ", "))

sortingAlgo/insertionSort/insertionSort.lua

@@ -0,0 +1,16 @@
+local function insertionSort(t)
+    local n = #t
+    for i = 2, n do
+        local item = t[i]
+        local j = i - 1
+        while j > 0 and t[j] > item do
+            t[j + 1] = t[j]
+            j = j - 1
+        end
+        t[j + 1] = item
+    end
+end
+
+local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
+insertionSort(t)
+print(table.concat(t, ", "))

sortingAlgo/mergeSort/mergeSort.lua

@@ -0,0 +1,45 @@
+local function mergeSort(t)
+    local n = #t
+    if n < 2 then
+        return t
+    end
+    local mid = math.floor(n / 2)
+    local left = {}
+    local right = {}
+    for i = 1, mid do
+        left[i] = t[i]
+    end
+    for i = mid + 1, n do
+        right[i - mid] = t[i]
+    end
+    left = mergeSort(left)
+    right = mergeSort(right)
+    local i = 1
+    local j = 1
+    local k = 1
+    while i <= #left and j <= #right do
+        if left[i] < right[j] then
+            t[k] = left[i]
+            i = i + 1
+        else
+            t[k] = right[j]
+            j = j + 1
+        end
+        k = k + 1
+    end
+    while i <= #left do
+        t[k] = left[i]
+        i = i + 1
+        k = k + 1
+    end
+    while j <= #right do
+        t[k] = right[j]
+        j = j + 1
+        k = k + 1
+    end
+    return t
+end
+
+local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
+mergeSort(t)
+print(table.concat(t, ", "))

sortingAlgo/pigeonholeSort/pigeonholeSort.lua

@@ -0,0 +1,32 @@
+local function pigeonholeSort(t)
+    local n = #t
+    local min = math.huge
+    local max = -math.huge
+    for i = 1, n do
+        if t[i] < min then
+            min = t[i]
+        end
+        if t[i] > max then
+            max = t[i]
+        end
+    end
+    local holes = {}
+    for i = 1, n do
+        holes[i] = 0
+    end
+    for i = 1, n do
+        holes[t[i] - min + 1] = holes[t[i] - min + 1] + 1
+    end
+    local k = 1
+    for i = 1, n do
+        while holes[i] > 0 do
+            t[k] = i + min - 1
+            k = k + 1
+            holes[i] = holes[i] - 1
+        end
+    end
+end
+
+local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
+pigeonholeSort(t)
+print(table.concat(t, ", "))

sortingAlgo/quickSort/quickSort.lua

@@ -0,0 +1,24 @@
+local function quickSort(t)
+    local n = #t
+    local function sort(t, start, end_)
+        if start < end_ then
+            local pivot = t[end_]
+            local i = start - 1
+            for j = start, end_ - 1 do
+                if t[j] <= pivot then
+                    i = i + 1
+                    t[i], t[j] = t[j], t[i]
+                end
+            end
+            t[i + 1], t[end_] = t[end_], t[i + 1]
+            local p = i + 1
+            sort(t, start, p - 1)
+            sort(t, p + 1, end_)
+        end
+    end
+    sort(t, 1, n)
+end
+
+local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
+quickSort(t)
+print(table.concat(t, ", "))

sortingAlgo/radixSort/radixSort.lua

@@ -0,0 +1,34 @@
+local function radixSort(t)
+    local n = #t
+    local max = 0
+    for i = 1, n do
+        if t[i] > max then
+            max = t[i]
+        end
+    end
+    local exp = 1
+    while max / exp > 0 do
+        local counts = {}
+        for i = 1, n do
+            local digit = math.floor(t[i] / exp) % 10
+            counts[digit] = (counts[digit] or 0) + 1
+        end
+        for i = 1, 9 do
+            counts[i] = (counts[i] or 0) + (counts[i - 1] or 0)
+        end
+        local sorted = {}
+        for i = n, 1, -1 do
+            local digit = math.floor(t[i] / exp) % 10
+            sorted[counts[digit]] = t[i]
+            counts[digit] = counts[digit] - 1
+        end
+        for i = 1, n do
+            t[i] = sorted[i]
+        end
+        exp = exp * 10
+    end
+end
+
+local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
+radixSort(t)
+print(table.concat(t, ", "))

sortingAlgo/selectionSort/selectionSort.lua

@@ -0,0 +1,16 @@
+local function selectionSort(t)
+    local n = #t
+    for i = 1, n - 1 do
+        local min = i
+        for j = i + 1, n do
+            if t[j] < t[min] then
+                min = j
+            end
+        end
+        t[i], t[min] = t[min], t[i]
+    end
+end
+
+local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
+selectionSort(t)
+print(table.concat(t, ", "))

sortingAlgo/shellSort/shellSort.lua

@@ -0,0 +1,20 @@
+local function shellSort(t)
+    local n = #t
+    local gap = math.floor(n / 2)
+    while gap > 0 do
+        for i = gap + 1, n do
+            local item = t[i]
+            local j = i - gap
+            while j > 0 and t[j] > item do
+                t[j + gap] = t[j]
+                j = j - gap
+            end
+            t[j + gap] = item
+        end
+        gap = math.floor(gap / 2)
+    end
+end
+
+local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
+shellSort(t)
+print(table.concat(t, ", "))