adding Sorting Algorithms information

Author: crizstian

12-chapter-Sorting-Algorithms.js

@@ -0,0 +1,104 @@
+class AdvanceSoritng {
+
+ static swap(arr, v1, v2) {
+   const temp = arr[v1];
+   arr[v1]    = arr[v2];
+   arr[v2]    = temp;
+ }
+
+
+  static mergeSort(arr) {
+    if (arr.length < 2) {
+      return;
+    }
+    let step = 1;
+    let left, right;
+    while (step < arr.length) {
+      left = 0;
+      right = step;
+      while (right + step <= arr.length) {
+         this.mergeArrays(arr, left, left+step, right, right+step);
+         left = right + step;
+         right = left + step;
+      }
+      if (right < arr.length) {
+         this.mergeArrays(arr, left, left+step, right, arr.length);
+      }
+      step *= 2;
+    }
+  }
+
+  static mergeArrays(arr, startLeft, stopLeft, startRight, stopRight) {
+    let rightArr = new Array(stopRight - startRight + 1);
+    let leftArr  = new Array(stopLeft - startLeft + 1);
+    let k = startRight;
+    for (let i = 0; i < (rightArr.length-1); i++) {
+      rightArr[i] = arr[k];
+      ++k;
+    }
+
+    k = startLeft;
+    for (let i = 0; i < (leftArr.length-1); i++) {
+      leftArr[i] = arr[k];
+      k++;
+    }
+    rightArr[rightArr.length-1] = Infinity; // a sentinel value
+    leftArr[leftArr.length-1]   = Infinity; // a sentinel value
+    let m = 0;
+    let n = 0;
+    for (k = startLeft; k < stopRight; k++) {
+      if (leftArr[m] <= rightArr[n]) {
+        arr[k] = leftArr[m];
+        m++;
+      } else {
+        arr[k] = rightArr[n];
+        n++;
+      }
+    }
+  }
+
+ static quickSort(alist) {
+   this.quickSortHelper(alist,0,alist.length-1);
+ }
+
+ static quickSortHelper(alist,first,last) {
+   if(first < last) {
+    const splitpoint = this.partition(alist,first,last);
+
+     this.quickSortHelper(alist,first,splitpoint-1);
+     this.quickSortHelper(alist,splitpoint+1,last);
+   }
+ }
+
+ static partition(alist,first,last) {
+   let pivotvalue = alist[first];
+
+   let leftmark  = first+1;
+   let rightmark = last;
+   let done = false;
+
+   while (!done) {
+     while (leftmark <= rightmark && alist[leftmark] <= pivotvalue) {
+       leftmark = leftmark + 1;
+     }
+
+     while (alist[rightmark] >= pivotvalue && rightmark >= leftmark) {
+       rightmark = rightmark -1;
+     }
+
+     if (rightmark < leftmark) {
+       done = true;
+     } else {
+       this.swap(alist, leftmark, rightmark);
+     }
+   }
+
+   let temp = alist[first];
+   alist[first] = alist[rightmark];
+   alist[rightmark] = temp;
+
+   return rightmark;
+ }
+}
+
+module.exports = AdvanceSoritng;

12-chapter-Sorting-Algorithms/12-chapter-advance-sorting-algorithms.js

@@ -0,0 +1,50 @@
+class BasicSorting {
+
+  static swap(arr, v1, v2) {
+    const temp = arr[v1];
+    arr[v1]    = arr[v2];
+    arr[v2]    = temp;
+  }
+
+   static bubbleSort(dataStore) {
+     const numElements = dataStore.length;
+     for (let outer = numElements; outer >= 2; outer--) {
+       for (let inner = 0; inner <= outer - 1; inner++) {
+         if(dataStore[inner] > dataStore[inner+1]) {
+          this.swap(dataStore, inner, inner+1);
+         }
+       }
+     }
+   }
+
+   static selectionSort(dataStore) {
+     let min;
+     for (let outer = 0; outer <= dataStore.length-2; outer++) {
+       min = outer;
+       for (let inner = outer + 1; inner <= dataStore.length-1; inner++) {
+         if (dataStore[inner] < dataStore[min]) {
+           min = inner;
+         }
+       }
+       this.swap(dataStore, outer, min);
+     }
+   }
+
+   static insertionSort(dataStore) {
+     let temp
+     let inner;
+
+     for (let outer = 1; outer <= dataStore.length-1; outer++) {
+       temp = dataStore[outer];
+       inner = outer;
+       while (inner > 0 && (dataStore[inner-1] >= temp)) {
+          dataStore[inner] = dataStore[inner-1];
+          --inner;
+       }
+       dataStore[inner] = temp;
+     }
+   }
+
+}
+
+module.exports = BasicSorting;

12-chapter-Sorting-Algorithms/12-chapter-basic-sorting-algorithms.js

@@ -0,0 +1,51 @@
+const BasicSorting   = require('./12-chapter-basic-sorting-algorithms');
+const AdvanceSoritng = require('./12-chapter-advance-sorting-algorithms');
+
+function setData(numElements = 100) {
+  let dataStore = [];
+  for (let i = 0; i < numElements; i++) {
+    dataStore[i] = Math.floor(Math.random() * (numElements + 1));
+  }
+  return dataStore;
+}
+
+function evaluteSortingAlgorithms(dataStore, typeSort) {
+  console.log(typeSort);
+  let start = new Date().getTime();
+
+  switch (typeSort) {
+    case 'Bubble Sort':
+      BasicSorting.bubbleSort(dataStore);
+    break;
+    case 'Selection Sort':
+      BasicSorting.selectionSort(dataStore);
+    break;
+    case 'Insertion Sort':
+      BasicSorting.insertionSort(dataStore);
+    break;
+    case 'Merge Sort':
+      AdvanceSoritng.mergeSort(dataStore);
+    break;
+    case 'Quick Sort':
+      AdvanceSoritng.quickSort(dataStore);
+    break;
+    default:
+      dataStore.sort();
+  }
+
+  let end = new Date().getTime();
+  console.log(`Elapsed time for the ${typeSort} on ${numElements} elements is: ${end} - ${start} = ${end - start} milliseconds.`);
+  console.log('###################');
+}
+
+const numElements = 10000;
+const sortTypes   = [
+  'Bubble Sort',
+  'Selection Sort',
+  'Insertion Sort',
+  'Quick Sort',
+  'Merge Sort',
+  'Default JS Sort'
+];
+
+sortTypes.forEach(type => evaluteSortingAlgorithms(setData(numElements), type));