Update documentation on the functions.

Shawn Bragdon · Shawn Bragdon · commit 58c7a5c7e65c · 2022-11-14T18:40:58.000-08:00
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -0,0 +1,59 @@
+{
+    "files.associations": {
+        "algorithm": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "exception": "cpp",
+        "functional": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "iterator": "cpp",
+        "limits": "cpp",
+        "list": "cpp",
+        "memory": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "unordered_map": "cpp",
+        "unordered_set": "cpp",
+        "utility": "cpp",
+        "vector": "cpp",
+        "xfacet": "cpp",
+        "xhash": "cpp",
+        "xiosbase": "cpp",
+        "xlocale": "cpp",
+        "xlocinfo": "cpp",
+        "xlocmon": "cpp",
+        "xlocnum": "cpp",
+        "xloctime": "cpp",
+        "xmemory": "cpp",
+        "xstddef": "cpp",
+        "xstring": "cpp",
+        "xtr1common": "cpp",
+        "xutility": "cpp"
+    }
+}
diff --git a/sortingAlgo/bubbleSort/bubbleSort.lua b/sortingAlgo/bubbleSort/bubbleSort.lua
@@ -1,3 +1,6 @@
+--- Sort an array using the bubble sort algorithm.
+--- @param t table
+--- @return table
 local function bubbleSort(t)
     local n = #t
     for i = 1, n do
@@ -9,6 +12,10 @@ local function bubbleSort(t)
     end
 end
 
+--[[
 local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
 bubbleSort(t)
-print(table.concat(t, ", "))
+print(table.concat(t, ", "))
+]]
+
+return bubbleSort
diff --git a/sortingAlgo/bucketsort/bucketSort.lua b/sortingAlgo/bucketsort/bucketSort.lua
@@ -1,3 +1,6 @@
+--- Sort an array using the bucket sort algorithm.
+--- @param t table
+--- @return table
 local function bucketSort(t)
     local n = #t
     local buckets = {}
@@ -20,8 +23,7 @@ local function bucketSort(t)
             end
         end
     end
+    return t
 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, ", "))
+return bucketSort
diff --git a/sortingAlgo/cocktailSort/cocktailSort.lua b/sortingAlgo/cocktailSort/cocktailSort.lua
@@ -1,3 +1,6 @@
+--- Sort an array using the cocktail sort algorithm.
+--- @param t table
+--- @return table
 local function cocktailSort(t)
     local n = #t
     local swapped = true
@@ -24,8 +27,7 @@ local function cocktailSort(t)
         end
         start = start + 1
     end
+    return t
 end
 
-local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
-cocktailSort(t)
-print(table.concat(t, ", "))
+return cocktailSort
diff --git a/sortingAlgo/combSort/combSort.lua b/sortingAlgo/combSort/combSort.lua
@@ -1,3 +1,6 @@
+--- Sort an array using comb sort algorithm.
+--- @param t table
+--- @return table
 local function combSort(t)
     local n = #t
     local gap = n
@@ -16,8 +19,7 @@ local function combSort(t)
             end
         end
     end
+    return t
 end
 
-local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
-combSort(t)
-print(table.concat(t, ", "))
+return combSort
diff --git a/sortingAlgo/countingSort/countingSort.lua b/sortingAlgo/countingSort/countingSort.lua
@@ -1,3 +1,6 @@
+--- Sort an array using counting sort algorithm.
+--- @param t table
+--- @return table
 local function countingSort(t)
     local n = #t
     local counts = {}
@@ -13,8 +16,7 @@ local function countingSort(t)
             end
         end
     end
+    return t
 end
 
-local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
-countingSort(t)
-print(table.concat(t, ", "))
+return countingSort
diff --git a/sortingAlgo/cycleSort/cycleSort.lua b/sortingAlgo/cycleSort/cycleSort.lua
@@ -1,3 +1,6 @@
+--- Sort an array using cycle sort algorithm.
+--- @param t table
+--- @return table
 local function cycleSort(t)
     local n = #t
     for i = 1, n do
@@ -29,8 +32,7 @@ local function cycleSort(t)
             t[pos], item = item, t[pos]
         end
     end
+    return t
 end
 
-local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
-cycleSort(t)
-print(table.concat(t, ", "))
+return cycleSort
diff --git a/sortingAlgo/insertionSort/insertionSort.lua b/sortingAlgo/insertionSort/insertionSort.lua
@@ -1,3 +1,6 @@
+--- Sort an array using the insertion sort algorithm.
+--- @param t table
+--- @return table
 local function insertionSort(t)
     local n = #t
     for i = 2, n do
@@ -9,8 +12,7 @@ local function insertionSort(t)
         end
         t[j + 1] = item
     end
+    return t
 end
 
-local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
-insertionSort(t)
-print(table.concat(t, ", "))
+return insertionSort
diff --git a/sortingAlgo/mergeSort/mergeSort.lua b/sortingAlgo/mergeSort/mergeSort.lua
@@ -1,3 +1,6 @@
+--- Sort an array using the merge sort algorithm.
+--- @param t table
+--- @return table
 local function mergeSort(t)
     local n = #t
     if n < 2 then
@@ -40,6 +43,4 @@ local function mergeSort(t)
     return t
 end
 
-local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
-mergeSort(t)
-print(table.concat(t, ", "))
+return mergeSort
diff --git a/sortingAlgo/pigeonholeSort/pigeonholeSort.lua b/sortingAlgo/pigeonholeSort/pigeonholeSort.lua
@@ -1,3 +1,6 @@
+--- Sort an array using the pigeonhole sort algorithm.
+--- @param t table
+--- @return table
 local function pigeonholeSort(t)
     local n = #t
     local min = math.huge
@@ -25,8 +28,7 @@ local function pigeonholeSort(t)
             holes[i] = holes[i] - 1
         end
     end
+    return t
 end
 
-local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
-pigeonholeSort(t)
-print(table.concat(t, ", "))
+return pigeonholeSort
diff --git a/sortingAlgo/quickSort/quickSort.lua b/sortingAlgo/quickSort/quickSort.lua
@@ -1,3 +1,6 @@
+--- Sort an array using the quick sort algorithm.
+--- @param t table
+--- @return table
 local function quickSort(t)
     local n = #t
     local function sort(t, start, end_)
@@ -17,8 +20,7 @@ local function quickSort(t)
         end
     end
     sort(t, 1, n)
+    return t
 end
 
-local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
-quickSort(t)
-print(table.concat(t, ", "))
+return quickSort
diff --git a/sortingAlgo/radixSort/radixSort.lua b/sortingAlgo/radixSort/radixSort.lua
@@ -1,3 +1,6 @@
+--- Sort an array using the radix sort algorithm.
+--- @param t table
+--- @return table
 local function radixSort(t)
     local n = #t
     local max = 0
@@ -27,8 +30,7 @@ local function radixSort(t)
         end
         exp = exp * 10
     end
+    return t
 end
 
-local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
-radixSort(t)
-print(table.concat(t, ", "))
+return radixSort
diff --git a/sortingAlgo/selectionSort/selectionSort.lua b/sortingAlgo/selectionSort/selectionSort.lua
@@ -1,3 +1,6 @@
+--- Sort an array using the selection sort algorithm.
+--- @param t table
+--- @return table
 local function selectionSort(t)
     local n = #t
     for i = 1, n - 1 do
@@ -9,8 +12,7 @@ local function selectionSort(t)
         end
         t[i], t[min] = t[min], t[i]
     end
+    return t
 end
 
-local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
-selectionSort(t)
-print(table.concat(t, ", "))
+return selectionSort
diff --git a/sortingAlgo/shellSort/Readme.md b/sortingAlgo/shellSort/Readme.md
@@ -1,33 +1,42 @@
 ﻿## Shell Sort
+
 Shell sort is an algorithm that first sorts the elements far apart from each other and successively reduces the interval between the elements to be sorted. It is a generalized version of insertion sort.
 
 In shell sort, elements at a specific interval are sorted. The interval between the elements is gradually decreased based on the sequence used. The performance of the shell sort depends on the type of sequence used for a given input array.
 
     shellSort(array, size)
-	  for interval i <- size/2n down to 1
-	    for each interval "i" in array
-	        sort all the elements at interval "i"
-	end shellSort
+      for interval i <- size/2n down to 1
+        for each interval "i" in array
+            sort all the elements at interval "i"
+    end shellSort
+
 ## Complexity
+
 Shell sort is an unstable sorting algorithm because this algorithm does not examine the elements lying in between the intervals.
+
 ### Time Complexities:
-* #### Worst Case Complexity: less than or equal to O(n<sup>2</sup>)
-* #### Best Case Complexities: O(n*log n)
-	When the array is already sorted, the total number of comparisons for each interval (or increment) is equal to the size of the array.
-* #### Average Case Complexity: O(n*log n)
-	It occurs when the elements of the array are in jumbled order (neither ascending nor descending).
+
+- #### Worst Case Complexity: less than or equal to O(n<sup>2</sup>)
+- #### Best Case Complexities: O(n\*log n)
+  When the array is already sorted, the total number of comparisons for each interval (or increment) is equal to the size of the array.
+- #### Average Case Complexity: O(n\*log n)
+  It occurs when the elements of the array are in jumbled order (neither ascending nor descending).
 
 ### Space Complexity:
+
 The space complexity for shell sort is **O(1)**
+
 ### Shell Sort Applications:
+
 Shell sort is used when
+
 1. calling a stack is overhead.
 2. recursion exceeds a limit.
 3. Insertion sort does not perform well when the close elements are far apart. Shell sort helps in reducing the distance between the close elements. Thus, there will be less number of swappings to be performed.
 
-###  Instruction for Running code:
+### Instruction for Running code:
 
 - Python
-    ```
-    python3 ShellSort.py
-    ```
+  ```
+  python3 ShellSort.py
+  ```
diff --git a/sortingAlgo/shellSort/shellSort.lua b/sortingAlgo/shellSort/shellSort.lua
@@ -1,3 +1,6 @@
+--- Sort an array using the shell sort algorithm.
+--- @param t table
+--- @return table
 local function shellSort(t)
     local n = #t
     local gap = math.floor(n / 2)
@@ -13,8 +16,7 @@ local function shellSort(t)
         end
         gap = math.floor(gap / 2)
     end
+    return t
 end
 
-local t = { 3, 2, 1, 4, 5, 6, 7, 8, 9, 10 }
-shellSort(t)
-print(table.concat(t, ", "))
+return shellSort
diff --git a/sortingAlgo/timSort/timSort.cpp b/sortingAlgo/timSort/timSort.cpp
diff --git a/sortingAlgo/timSort/timSort.lua b/sortingAlgo/timSort/timSort.lua
