Handle empty array input in selection sort

Backtracking/NQueens.js

@@ -1,8 +1,9 @@
 class NQueens {
   constructor(size) {
-    if (size < 0) {
-      throw RangeError('Invalid board size')
+    if (size <= 0) {
+      throw RangeError('Board size must be a positive integer')
     }
+
     this.board = new Array(size).fill('.').map(() => new Array(size).fill('.'))
     this.size = size
     this.solutionCount = 0
@@ -40,7 +41,7 @@ class NQueens {
   solve(col = 0) {
     if (col >= this.size) {
       this.solutionCount++
-      return true
+      return
     }
 
     for (let i = 0; i < this.size; i++) {
@@ -50,8 +51,6 @@ class NQueens {
         this.removeQueen(i, col)
       }
     }
-
-    return false
   }
 
   printBoard(output = (value) => console.log(value)) {

Search/BinarySearch.js

@@ -8,44 +8,46 @@
  */
 
 function binarySearchRecursive(arr, x, low = 0, high = arr.length - 1) {
+  if (!Array.isArray(arr) || arr.length === 0) {
+    return -1
+  }
+
   const mid = Math.floor(low + (high - low) / 2)
 
   if (high >= low) {
     if (arr[mid] === x) {
-      // item found => return its index
       return mid
     }
 
     if (x < arr[mid]) {
-      // arr[mid] is an upper bound for x, so if x is in arr => low <= x < mid
       return binarySearchRecursive(arr, x, low, mid - 1)
     } else {
-      // arr[mid] is a lower bound for x, so if x is in arr => mid < x <= high
       return binarySearchRecursive(arr, x, mid + 1, high)
     }
-  } else {
-    // if low > high => we have searched the whole array without finding the item
-    return -1
   }
+
+  return -1
 }
+
 function binarySearchIterative(arr, x, low = 0, high = arr.length - 1) {
+  if (!Array.isArray(arr) || arr.length === 0) {
+    return -1
+  }
+
   while (high >= low) {
     const mid = Math.floor(low + (high - low) / 2)
 
     if (arr[mid] === x) {
-      // item found => return its index
       return mid
     }
 
     if (x < arr[mid]) {
-      // arr[mid] is an upper bound for x, so if x is in arr => low <= x < mid
       high = mid - 1
     } else {
-      // arr[mid] is a lower bound for x, so if x is in arr => mid < x <= high
       low = mid + 1
     }
   }
-  // if low > high => we have searched the whole array without finding the item
+
   return -1
 }
 

Sorts/QuickSort.js

@@ -1,30 +1,28 @@
 /**
- * @function QuickSort
- * @description Quick sort is a comparison sorting algorithm that uses a divide and conquer strategy.
- * @param {Integer[]} items - Array of integers
- * @return {Integer[]} - Sorted array.
- * @see [QuickSort](https://en.wikipedia.org/wiki/Quicksort)
+ * @function quickSort
+ * @description Quick Sort is a divide-and-conquer comparison-based sorting algorithm.
+ * @param {number[]} items - Array of integers
+ * @returns {number[]} - Sorted array
+ * @timecomplexity Average: O(n log n), Worst: O(n²)
+ * @spacecomplexity O(n)
+ * @see https://en.wikipedia.org/wiki/Quicksort
  */
 function quickSort(items) {
-  const length = items.length
+  if (items.length <= 1) return items
 
-  if (length <= 1) {
-    return items
-  }
-  const PIVOT = items[0]
-  const GREATER = []
-  const LESSER = []
+  const pivotIndex = Math.floor(items.length / 2)
+  const pivot = items[pivotIndex]
+
+  const lesser = []
+  const greater = []
 
-  for (let i = 1; i < length; i++) {
-    if (items[i] > PIVOT) {
-      GREATER.push(items[i])
-    } else {
-      LESSER.push(items[i])
-    }
+  for (let i = 0; i < items.length; i++) {
+    if (i === pivotIndex) continue
+    if (items[i] < pivot) lesser.push(items[i])
+    else greater.push(items[i])
   }
 
-  const sorted = [...quickSort(LESSER), PIVOT, ...quickSort(GREATER)]
-  return sorted
+  return [...quickSort(lesser), pivot, ...quickSort(greater)]
 }
 
 export { quickSort }

Sorts/SelectionSort.js

@@ -12,7 +12,13 @@ export const selectionSort = (list) => {
   if (!Array.isArray(list)) {
     throw new TypeError('Given input is not an array')
   }
-  const items = [...list] // We don't want to modify the original array
+
+  if (list.length === 0) {
+    return []
+  }
+
+  const items = [...list]
+
   const length = items.length
   for (let i = 0; i < length - 1; i++) {
     if (typeof items[i] !== 'number') {