refined a bit on sorting algorithm

Author: Williammer

src/_.general/sorting.js

@@ -14,9 +14,10 @@ function checkArray(arr) {
 }
 
 /**
- * Bubble sort, sorted by swapping item pairs(if needed) from the start postion to the end of the array.
+ * Bubble sort, sorted by swapping item pairs(if needed) from the start postion to the end of the
+ * array.
  * First round will have a largest item swapped to the array end, and second round will have the
- * second largest item swapped to array end minus one position, and so on until all items are sorted.
+ * second largest item swapped to array end - 1 position, and so on until all items are sorted.
  *
  * Time complexity: O(N, N^2)
  * Space complexity: O(1)
@@ -28,18 +29,24 @@ function checkArray(arr) {
 export function bubbleSort(array) {
   const arr = array.slice();
   checkArray(arr);
+  let hasSwap = false;
   for (let i = arr.length - 1; i > 0; i--) {
     for (let j = 0; j < i; j++) {
       if (arr[j] > arr[j + 1]) {
         swap(arr, j, j + 1);
+        hasSwap = true;
       }
     }
+    if (!hasSwap) {
+      return arr;
+    }
   }
   return arr;
 }
 
 /**
- * Selection sort, sorted by selecting min to max items for the start to the end position of the array.
+ * Selection sort, sorted by selecting min to max items for the start to the end position of the
+ * array.
  *
  * Time complexity: O(N^2)
  * Space complexity: O(1)
@@ -129,12 +136,12 @@ export function shellSort(array, base = 3) {
 }
 
 /**
- * Quick sort, sorted by performing a partition process for a chosen pivot item, and the same is done
- * for the left/right partitioned parts, and so on.
+ * Quick sort, sorted by performing a partition process for a chosen pivot item, and the same is
+ * done for the left/right partitioned parts, and so on.
  * The partition process will swap pairs of items until the left part are all smaller than pivot,
  * and right part are all larger.
  * This function implemented it by creating extra partitioned array upon each partition process.
- * It's concise and easy to read, but has extra space complexity than quickSort implementation below.
+ * It's concise and easy to read, but has extra space complexity.
  *
  * Time complexity: O(NlogN, N^2)
  * Space complexity: O(N)
@@ -157,8 +164,8 @@ export function quickSortWithArray(array) {
 }
 
 /**
- * Quick sort, sorted by performing a partition process for a chosen pivot item, and the same is done
- * for the left/right partitioned parts, and so on.
+ * Quick sort, sorted by performing a partition process for a chosen pivot item, and the same is
+ * done for the left/right partitioned parts, and so on.
  * The partition process will swap pairs of items until the left part are all smaller than pivot,
  * and right part are all larger.
  *
@@ -169,34 +176,37 @@ export function quickSortWithArray(array) {
  * @return {Array}
  *
  */
-export function quickSort(arr, lo, hi) {
-  checkArray(arr);
+export function quickSort(array, lo, hi) {
+  checkArray(array);
   lo = typeof lo === "number" ? lo : 0;
-  hi = typeof hi === "number" ? hi : arr.length;
-
-  if (hi <= lo) return arr;
+  hi = typeof hi === "number" ? hi : array.length;
+  if (hi <= lo) return array;
 
-  let start = lo;
-  let end = hi;
-  const pivot = arr[lo];
+  const partition = (arr, left, right) => {
+    let start = left;
+    let end = right;
+    const pivot = arr[left];
 
-  while (start < end) {
-    while (arr[++start] <= pivot) if (start === hi) break;
-    while (arr[--end] >= pivot) if (end === lo) break;
-    if (start >= end) break;
-    swap(arr, start, end);
-  }
-  swap(arr, lo, end);
-
-  quickSort(arr, lo, end);
-  quickSort(arr, end + 1, hi);
+    while (start < end) {
+      while (arr[++start] <= pivot) if (start === right) break; // eslint-disable-line no-plusplus
+      while (arr[--end] >= pivot) if (end === left) break; // eslint-disable-line no-plusplus
+      if (start >= end) break;
+      swap(arr, start, end);
+    }
+    swap(arr, left, end);
+    return end;
+  };
+  const pivot = partition(array, lo, hi);
+  quickSort(array, lo, pivot);
+  quickSort(array, pivot + 1, hi);
 
-  return arr;
+  return array;
 }
 
 /**
- * Merge sort, sorted by recursively dividing the array into two sub-arrays and merging corresponding
- * sub-arrays back into a sorted array. The merge process ensures that the merged array is sorted.
+ * Merge sort, sorted by recursively dividing the array into two sub-arrays and merging
+ * corresponding sub-arrays back into a sorted array. The merge process ensures that the merged
+ * array is sorted.
  *
  * Time complexity: O(NlogN)
  * Space complexity: O(N)
@@ -211,41 +221,36 @@ export function mergeSort(array) {
   if (arr.length < 2) {
     return arr;
   }
-  const merge = (arr1, arr2) => {
+  const merge = (a, b) => {
     const result = [];
-    const arrLen1 = arr1.length;
-    const arrLen2 = arr2.length;
-    let pt1 = 0;
-    let pt2 = 0;
-
-    while (pt1 < arrLen1 && pt2 < arrLen2) {
-      if (arr1[pt1] === arr2[pt2]) {
-        result.push(arr1[pt1], arr2[pt2]);
-        pt1 += 1;
-        pt2 += 1;
-      } else if (arr1[pt1] > arr2[pt2]) {
-        result.push(arr2[pt2]);
-        pt2 += 1;
+    const lenA = a.length;
+    const lenB = b.length;
+    let i = 0;
+    let j = 0;
+    while (i < lenA && j < lenB) {
+      if (a[i] === b[j]) {
+        result.push(a[i], b[j]);
+        i += 1;
+        j += 1;
+      } else if (a[i] > b[j]) {
+        result.push(b[j]);
+        j += 1;
       } else {
-        result.push(arr1[pt1]);
-        pt1 += 1;
+        result.push(a[i]);
+        i += 1;
       }
     }
-
-    return result.concat(arr1.slice(pt1)).concat(arr2.slice(pt2));
+    return result.concat(a.slice(i)).concat(b.slice(j));
   };
-  const mid = Math.floor(arr.length - 1 / 2);
-  const leftArr = arr.slice(0, mid);
-  const rightArr = arr.slice(mid);
-
-  return merge(mergeSort(leftArr), mergeSort(rightArr));
+  const mid = Math.floor(arr.length / 2);
+  return merge(mergeSort(arr.slice(0, mid)), mergeSort(arr.slice(mid)));
 }
 
 /**
  * Heap sort, sorted by using the heapify process of the Heap data structure.
  * The Heap data structure looks like a binary tree, but there cannot be `null` gap within it.
- * A proper Heap should have the property that all parent nodes are larger than or equal to its child
- * nodes.
+ * A proper Heap should have the property that all parent nodes are larger than or equal to its
+ * child nodes.
  * The heapify process can find the largest item of the array at a time, and then swap the largest
  * item to the end of the array. This process is repeated until all the array become sorted.
  *