insertion sort with splice and without using swap method

Author: rohan-paul

Sorting/insertion-sort-with-splice.js

@@ -0,0 +1,38 @@
+/* Algorithm -
+
+A) Loop from i = 1 (second element of the array) to n-1.
+B) Pick element arr[i] and insert it into sorted sequence arr[0…i-1]
+C) Say I get 12, 11 as the second and third element. Since 11 is smaller than 12, move 12 and insert 11 before 12
+*/
+
+insertionSort = arr => {
+
+  if (!Array.isArray(arr) || arr.length < 2) {
+    return arr;
+  }
+
+  let array = arr.slice(0);
+
+
+    /* A>  Here each time I find aff[i] < arr[j] I effectively have to swap the position of i and j.
+    B> But instead of using a swap function, I returned a spliced array where the j-th position is replaced with i-th position.
+    C> Note, < arr.splice(j, 0, 'item')  > means that at j-th position I am placing the 'item' and removing zero element.
+    D> And  < arr.splice(i, 1)[0] > will delete 1 element from i-th position and return and return an array containing deleted element. Hence I am getting that delete element by accessing [0]
+    */
+
+  for (let i = 1; i < array.length; i++ ) {
+    for ( let j = 0; j < i; j++ ) {
+
+      if ( array[i] < array[j] ) {
+        array.splice(j, 0, array.splice(i, 1)[0])
+        break;
+      }
+    }
+  }
+  return array;
+}
+
+const list = [54, 26, 93, 17, 77, 31, 44, 55, 20]
+console.log(insertionSort(list));
+
+// [ 17, 20, 26, 31, 44, 54, 55, 77, 93 ]

Sorting/insertion_sort.js renamed to Sorting/insertion_sort-with-swap.js

@@ -24,9 +24,12 @@ function insertion_sort(array) {
     var i, j;
 
    /*
-   1. Assume first element is sorted
-   2. Add first unsorted element to sorted array
-   3. Compare new element in sorted array with previous elements to determine correct destination index in sorted array
+   1. Assume first element is sorted. So, Loop from i = 1 (second element of the array) to n-1.
+
+   2. Add first unsorted element to sorted array.
+
+   3. Compare new element in sorted array with previous elements to determine correct destination index in sorted array. Say I get 12, 11 as the second and third element. Since 11 is smaller than 12, move 12 and insert 11 before 12
+
    4. In the below, at the last step, I had to decrement j by one, to stop the while loop. Because, with the decremented value of j, in the next iteration of the loop, one of the while loop condition will fail
    */
 

Sorting/quick-sort-Lomuto.js

@@ -41,34 +41,10 @@ function partitionLomuto(array, left, right) {
 
 /******************* Testing Lomuto algorithm *********************/
 
-function getRandomInt(min, max) {
-	return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
 let arr = Array.from({length : 20}, () => Math.floor(Math.random() * 20));
 console.log(arr); //printing unsorted array
 
 arr = quicksortLomuto(arr, 0, arr.length - 1);
 console.log(arr);
 
 
-/* Explanation of < Math.floor(Math.random() * (max - min + 1)) + min >
-
-By adding 1, I am making the maximum inclusive ( the minimum is inclusive anyway). Because, the Math.random() function returns a floating-point, pseudo-random number in the range from 0 inclusive up to but not including 1. the formula can generate the correct amount of numbers but they always start at 0 because the range from Math.random starts from 0. https://teamtreehouse.com/community/need-an-explanation
-
-Math.random() returns a number from 0 to 1, not including one. Flooring this number will always result in a zero.
-
-If you multiply this float by the max prior to flooring, you will get numbers all the way up to the maximum, including those below the minimum, but not the maximum itself. Say you have 10 as the maximum, you cannot get a 10.
-
-In order to rule out those below the minimum, you subtract the minimum from the maximum. In order to include the maximum, you add one. This is all multiplied by the random floating point number between 0 and 1.
-
-At that point, we aren't quite there. You will be receiving numbers based on the range between the minimum and maximum as explained above. Adding the minimum back in, post-randomizing, ensure that you have numbers that are between the minimum and the maximum.
-
-TLDR: The range of numbers (i.e. the number of numbers between min and max) is defined by those within the floor method's parentheses. The minimum added at the end ensures these numbers are between the desired minimum and maximum.
-
-By subtracting the minimum number from the maximum, you define the range. Say you have minimum of 5 and a maximum of 20, you will get the range of 15. There are 15 possible numbers that you could select at random between these bounds.
-
-Paul-Note - So, if I dont add Min of 5, the formulae will give me all the random numbers between 0 and 15. But I want between 5 and 20. So thats why I add back the min.
-
-Another great visual explanation at - https://stackoverflow.com/questions/1527803/generating-random-whole-numbers-in-javascript-in-a-specific-range
- */

Sorting/quick-sort-basic-recursion.js

@@ -33,12 +33,6 @@ function quickSortBasic(array) {
 
 /******************* Testing Quick sort algorithm *********************/
 
-// Returns a random integer between min (inclusive) and max (inclusive). Using Math.round() will give a non-uniform distribution, which we dont want in this case.
-
-function getRandomInt(min, max) {
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
 let arr = Array.from({length : 20}, () => Math.floor(Math.random() * 20));
 
 console.log(arr); //printing unsorted array