binary search standard simple solution

Author: rohan-paul

Search/binary-search-basic.js

@@ -0,0 +1,25 @@
+// SOLUTION-1
+
+binarySearch = ( arr, value ) => {
+
+  let estimatedIndex, minIndex = 0, maxIndex = arr.length - 1;
+
+  while ( minIndex <= maxIndex ) {
+
+    estimatedIndex = Math.floor((minIndex + maxIndex) / 2);
+
+    if (arr[estimatedIndex] === value ) {
+      return estimatedIndex
+    }
+    else if (arr[estimatedIndex] < value) {
+      // then start the next search from middle position towards right
+      minIndex = estimatedIndex + 1;
+    }
+    else {
+      // i.e. the value is in the left half, so reduce the maxIndex to 1 less than the middle position
+      maxIndex = estimatedIndex - 1
+    }
+  }
+}
+
+console.log(binarySearch([2, 4, 1, 5], 5));

Sorting/bubble-sort-basic.js renamed to Sorting/bubble-sort-basic-FUTURE-REFERENCE.js

@@ -9,7 +9,7 @@ swap = (arr, i, j) => {
   arr[j] = temp;
 }
 
-// Necessary warning :) :) - this is a super basic implementation  to understand the principle behind bubble sort (going through all comparisons) but there's huge room for performance improvement on this.
+// SOLUTION-1 - Necessary warning :) :) - this is a super basic implementation  to understand the principle behind bubble sort (going through all comparisons) but there's huge room for performance improvement on this.
 
 bubbleSortBasicAscending = (arr) => {
 
@@ -39,7 +39,7 @@ bubbleSortBasicDescending = (arr) => {
 
 console.log(bubbleSortBasicDescending(array1));
 
-/* A more optimal solution, by reducing some of the loop execution are not done in this solution.
+/* SOLUTION - 2 - A more optimal solution, by reducing some of the loop execution are not done in this solution.
 So, here, I only do the loops and swaps for the cases when I find a mis-placed element, i.e. larger-element placed before smaller in an ascending sort
 */
 bubbleSortAscending = arr => {

Sorting/insertion-sort-with-splice.js

@@ -14,17 +14,41 @@ insertionSort = 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]
+/* 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 element 'item' while removing zero element from the array.
+
+AND remember array.splice() MUTATES THE ORIGINAL ARRAY AND RETURN THAT MUTATED ARRAY
+
+D> And  < arr.splice(i, 1)[0] > will delete 1 element at i-th position and return an array containing deleted element. Hence I am getting that deleted element by using 0-index position with [0]
+
+This is how the splice is working here -
+
+Pick-out (or return) the deleted element from the given array
+
+let myArr1 = [ 2, 1, 3, 4]
+
+console.log(myArr1.splice(1, 1)[0]); // => 1
+
+Then replace the 0-index element with the third-argument in the .splice() method
+
+let myArr = [ 2, 1, 3, 4]
+
+myArr.splice(0, 0, myArr.splice(1, 1)[0]);
+
+console.log(myArr); // => [ 1, 2, 3, 4 ]
+
+
+
+
     */
 
-  for (let i = 1; i < array.length; i++ ) {
-    for ( let j = 0; j < i; j++ ) {
+  for (let i = 0; i < array.length; i++ ) {
+    for ( let j = 1; j < i; j++ ) {
 
       if ( array[i] < array[j] ) {
-        array.splice(j, 0, array.splice(i, 1)[0])
+        array.splice( j, 0, array.splice(i, 1)[0] )
         break;
       }
     }
@@ -35,4 +59,16 @@ insertionSort = arr => {
 const list = [54, 26, 93, 17, 77, 31, 44, 55, 20]
 console.log(insertionSort(list));
 
-// [ 17, 20, 26, 31, 44, 54, 55, 77, 93 ]
+// [ 17, 20, 26, 31, 44, 54, 55, 77, 93 ]
+
+/* 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;
+} */

Sorting/mergeSort-Basic-Recursive.js renamed to Sorting/mergeSort-Basic-Recursive-FUTURE-REFERENCE.js

@@ -1,8 +1,8 @@
-// ROHAN'S NOTE IS TO REFER HERE IN FUTURE - Implementation of merge-sort algorithm, to sort an array of numbers in O(N×log(N)) time.
+// ROHAN'S NOTE HERE FOR FUTURE REFERENCE - Implementation of merge-sort algorithm, to sort an array of numbers in O(N×log(N)) time.
 
 /* https://www.geeksforgeeks.org/merge-sort/
 
-Like QuickSort, Merge Sort is a Divide and Conquer algorithm. It divides input array in two halves, calls itself for the two halves and then merges the two sorted halves. The merge() function is used for merging two halves. The merge(arr, l, m, r) is key process that assumes that arr[l..m] and arr[m+1..r] are sorted and merges the two sorted sub-arrays into one. See following pseudo-code.
+Like QuickSort, Merge Sort is a Divide and Conquer algorithm. It divides input array in two halves, calls itself for the two halves and then merges the two sorted halves. The helper function merge2SortedArrays() is used for merging two halves. The merge(arr, l, m, r) is key process that assumes that arr[l..m] and arr[m+1..r] are sorted and merges the two sorted sub-arrays into one. See following pseudo-code.
 
 MergeSort(arr[], l,  r)
 If r > l
@@ -24,7 +24,7 @@ A> The array is recursively divided in two halves till the size becomes 1.
 
 B> Once the size becomes 1, the merge processes comes into action, meaning I invoke the merge function on the 2 single-element arrays. That is, take adjacent pairs of two singleton lists, sort the elements of the 2 list, and merge them to form a list (ie array) of 2 elements .
 
-C> So the merge() function below is a completely independent function and will just take 2 sorted-arrays ( the individual arrays MUST BE SORTED ),  and then concat the elements to forma a single SORTED array. That is, within the merge() function before pushing the elements to the final result array (which will be the output from merge ) it checks for proper-sorting between the 2 elements on the 2 arrays.
+C> So the merge2SortedArrays() function below is a completely independent function and will just take 2 sorted-arrays ( the individual arrays MUST BE SORTED ),  and then concat the elements to forma a single SORTED array. That is, within the merge() function before pushing the elements to the final result array (which will be the output from merge ) it checks for proper-sorting between the 2 elements on the 2 arrays.
 
 merge( [1, 3, 5, 7 ] , [ 2, 4, 6, 8] ) >>  will produce the below