Add a Folder with Sorting algorithms in js

    - add a bubble sort algorithm
    - add an insertion sort algorithm
    - add a quick sort algorithm
    - add a selection sort algorithm

Author: WaithakaGuru

bubbleSort.js

@@ -0,0 +1,38 @@
+// on 26th August 2024 [12:06 PM ]
+//function to perform bubble sort 
+
+// a simple function to return the length of an iterable eg an ARRAY, STRING, e.t.c
+function count(iterable){
+    if(!isNaN(iterable)) iterable = `${iterable}`;
+    let i =0;
+    for(const item of iterable) i++;
+    return i;
+}
+
+/* the bubble sort logic function*/
+
+function bubbleSort(array){
+    let iterations = sort(array), iterationsCount =[];
+    while(iterations.swaps > 0){
+        iterationsCount.push(iterations.swaps);
+        iterations = sort(iterations.array);
+    }
+    return [iterations.array, `Nos. of swaps made per Iteration: ${iterationsCount}`, 
+        `Total iterations(Sort Pass) made to sort the List: ${count(iterationsCount)}`, `List of ${count(array)} elements`];
+  function sort (array){ 
+    let len = count(array), c=0;
+    for(let i=len; i>=0; i--){
+        if(array[i]<array[i-1]){
+            [array[i], array[i-1]] = [array[i-1], array[i]]; // swapping the items positions
+            c++;
+        }
+    }
+    return {swaps:c, array};
+ }
+}
+
+//testing the function 
+console.log(bubbleSort([22,3,44,5,6,8,7,10,9,15]));// normal list
+console.log(bubbleSort([1,3,2,4,4,5,6,7,8,9])); // list with only one misplaced element
+console.log(bubbleSort([13,12,11,9,8,7,6,5,3,2])); // a reverse-ordered list
+console.log(bubbleSort([10,11,22,33,44,55,66,77,88,99])); // a sorted list

insertionSort.js

@@ -0,0 +1,32 @@
+// On the evening of 26th August 2024
+// creating an insertion Sort algorithm
+
+// a function to get the length of an iterable eg ARRAY, STRING e.t.c
+function count (iterable){
+    if(!isNaN(iterable))iterable = `${iterable}`;
+    let i= 0;
+    for(const item of iterable) i++;
+    return i;
+}
+// the Insertion sort logic
+function insertionSort(array){
+    let sorted= [], len = count(array), temp, swaps = 0, swapsCount= [], iterations = 0;
+    sorted[0] = array[0];
+    for(let i = 1; i<len; i++){
+        for(let j = 0; j<count(sorted); j++){
+            if(array[i]<sorted[j]){
+                [array[i], sorted[j]] = [sorted[j], array[i]];
+                swaps++;
+            }
+        }
+        sorted.push(array[i]);
+        swapsCount.push(swaps);
+        iterations ++;
+    }
+    return[sorted, `No of swaps per iteration ${swapsCount}`, `No of iterations made to complete the sort ${iterations}`]
+}
+
+console.log(insertionSort([22,3,44,5,6,8,7,10,9,15]));// normal list
+console.log(insertionSort([1,3,2,4,4,5,6,7,8,9])); // list with only one misplaced element
+console.log(insertionSort([13,12,11,9,8,7,6,5,3,2])); // a reverse-ordered list
+console.log(insertionSort([10,11,22,33,44,55,66,77,88,99])); // a sorted list

quickSort.js

@@ -0,0 +1,42 @@
+// Now into Advanced sorting algorithms am going to code the 
+//    quick sort Algorithm (it's a recursive one) On 28th August 2024 [ 10:47 PM ]
+import { quickSort } from "./allSortAlogs";
+// fn to calc the length of a list of items ie(no of items in a list)
+function count(iterable){
+    if(!isNaN(iterable)) iterable = `${iterable}`;
+    let i = 0;
+    for(const item of iterable) i++;
+    return i;
+}
+function rangeCount(iterable, start, end){
+    if(!isNaN(iterable)) iterable = `${iterable}`;
+    let i = 0;
+    for( j = start; j<=end; j++) i++;
+    return i;
+}
+// quick sort logic
+function quickSort(list=[], start =0 ,end= count(list) - 1){
+    if(start < end){
+        let pivotIndex = partition(list, start, end);
+        quickSort(list, start, pivotIndex-1);
+        quickSort(list, pivotIndex+1, end);
+    }
+    return list;
+}
+function partition(list, start, end){
+    let pivot = list[end], i = start -1;
+    for(let k = start; k<end; k++){
+        if(list[k] < pivot){
+            i++;
+            [list[i], list[k]] = [list[k], list[i]];
+        }
+    }
+    [list[i+1], list[end]] = [list[end],list[i+1]];
+    return i+1;
+}
+
+// testing the function
+console.log(quickSort([1,3,2,4,4,5,6,7,8,9])); // list with only one misplaced element
+console.log(quickSort([13,12,11,9,8,7,6,5,3,2])); // a reverse-ordered list
+console.log(quickSort([10,11,22,33,44,55,66,77,88,99])); // a sorted list
+console.log(quickSort([22,3,44,5,6,8,7,10,9,15]));// normal list

selectionSort.js

@@ -0,0 +1,34 @@
+console.log("Still on 31st July" + " Let's continue coding");
+/*      --SELECTION SORT--
+ *
+ *
+ */ 
+
+// fn to give the length of the List of items (i.e no of items)
+function count(iterable){
+    if(!isNaN(iterable)) iterable = `${iterable}`;
+    let i = 0;
+    for(const item of iterable) i++;
+    return i;
+}
+
+// selection sort logic
+function selectionSort (list){
+    let posOfLargest, len = count(list), checks = 0, iterations = 0, checksCount= [];
+    for(let i = len-1; i>0; i--){
+        posOfLargest = 0;
+        for(let j = 0; j<=i; j++){
+            if(list[j]>list[posOfLargest]) {
+                posOfLargest = j; checks++;
+            }
+        }
+        checksCount.push(checks);
+        [list[i], list[posOfLargest]] = [list[posOfLargest], list[i]];
+        iterations ++;
+    }
+    return [list, `No of checks done per iteration: ${checksCount}`, `No of iterations for complete sort ${iterations}`]
+}
+console.log(selectionSort([1,3,2,4,4,5,6,7,8,9])); // list with only one misplaced element
+console.log(selectionSort([13,12,11,9,8,7,6,5,3,2])); // a reverse-ordered list
+console.log(selectionSort([10,11,22,33,44,55,66,77,88,99])); // a sorted list
+console.log(selectionSort([22,3,44,5,6,8,7,10,9,15]));// normal list