merge: Add alternative implementation for InsertionSort and relative test. Add additional algorithm description (TheAlgorithms#915)

HereBeAndre · Andrea Tota · web-flow · commit 00f593662b75 · 2022-03-04T19:41:37.000+05:30
Co-authored-by: Andrea Tota &lt;tota@qi4m.com&gt;
diff --git a/Sorts/InsertionSort.js b/Sorts/InsertionSort.js
@@ -1,9 +1,10 @@
 /* In insertion sort, we divide the initial unsorted array into two parts;
-* sorted part and unsorted part. Initially the sorted part just has one
-* element (Array of only 1 element is a sorted array). We then pick up
-* element one by one from unsorted part; insert into the sorted part at
-* the correct position and expand sorted part one element at a time.
-*/
+ * sorted part and unsorted part. Initially the sorted part just has one
+ * element (Array of only 1 element is a sorted array). We then pick up
+ * element one by one from unsorted part; insert into the sorted part at
+ * the correct position and expand sorted part one element at a time.
+ */
+
 export function insertionSort (unsortedList) {
   const len = unsortedList.length
   for (let i = 1; i < len; i++) {
@@ -19,3 +20,43 @@ export function insertionSort (unsortedList) {
     unsortedList[j + 1] = tmp
   }
 }
+
+/**
+ * @function insertionSortAlternativeImplementation
+ * @description InsertionSort is a stable sorting algorithm
+ * @param {Integer[]} array - Array of integers
+ * @return {Integer[]} - Sorted array
+ * @see [InsertionSort](https://en.wikipedia.org/wiki/Quicksort)
+ */
+
+/*
+  * Big-O Analysis
+      * Time Complexity
+        - O(N^2) on average and worst case scenario
+        - O(N) on best case scenario (when input array is already almost sorted)
+      * Space Complexity
+        - O(1)
+*/
+
+export function insertionSortAlternativeImplementation (array) {
+  const length = array.length
+  if (length < 2) return array
+
+  for (let i = 1; i < length; i++) {
+    // Take current element in array
+    const currentItem = array[i]
+    // Take index of previous element in array
+    let j = i - 1
+
+    // While j >= 0 and previous element is greater than current element
+    while (j >= 0 && array[j] > currentItem) {
+      // Move previous, greater element towards the unsorted part
+      array[j + 1] = array[j]
+      j--
+    }
+    // Insert currentItem number at the correct position in sorted part.
+    array[j + 1] = currentItem
+  }
+  // Return array sorted in ascending order
+  return array
+}
diff --git a/Sorts/test/InsertionSort.test.js b/Sorts/test/InsertionSort.test.js
@@ -0,0 +1,19 @@
+import { insertionSortAlternativeImplementation } from '../InsertionSort'
+
+describe('insertionSortAlternativeImplementation', () => {
+  it('expects to work with empty array', () => {
+    expect(insertionSortAlternativeImplementation([])).toEqual([])
+  })
+
+  it('expects to return input array when array.length is less than 2', () => {
+    const input = [3]
+    expect(insertionSortAlternativeImplementation(input)).toEqual(input)
+  })
+
+  it('expects to return array sorted in ascending order', () => {
+    expect(insertionSortAlternativeImplementation([14, 11])).toEqual([11, 14])
+    expect(insertionSortAlternativeImplementation([21, 22, 23])).toEqual([21, 22, 23])
+    expect(insertionSortAlternativeImplementation([1, 3, 2, 3, 7, 2])).toEqual([1, 2, 2, 3, 3, 7])
+    expect(insertionSortAlternativeImplementation([1, 6, 4, 5, 9, 2])).toEqual([1, 2, 4, 5, 6, 9])
+  })
+})
