adding test examples and index module

Author: crizstian

12-chapter-Sorting-Algorithms/implentation.js

@@ -1,4 +1,4 @@
 (function (exports) {
-  const {sort} = require('./sort-module')
+  const sort = require('./sort-module')
   Object.assign(exports, sort)
 }((typeof module.exports !== undefined) ? module.exports : window))

12-chapter-Sorting-Algorithms/index.js

@@ -1,12 +1,12 @@
-# Sort Algorithms with ES6 
+# Sort Algorithms with ES6
 
 ### Code Examples
-[Basic Sorting Algorithms](./basic-sort.js)
-[Advanced Sorting Algorithms - Quick Sort](./quick-sort.js)
-[Advanced Sorting Algorithms - Merge Sort](./merge-sort.js)
-[Module](./sort-module.js)
-[Implentation](./implementation.js)
-[Import Module](./index.js)
+- [Basic Sorting Algorithms](./basic-sort.js)
+- [Advanced Sorting Algorithms - Quick Sort](./quick-sort.js)
+- [Advanced Sorting Algorithms - Merge Sort](./merge-sort.js)
+- [Module](./sort-module.js)
+- [Implentation](./implementation.js)
+- [Import Module](./index.js)
 
 ### Description
 

12-chapter-Sorting-Algorithms/readme.md

@@ -15,31 +15,34 @@
     alist[v2] = temp
   }
 
+  const methods = {
+    bubbleSort () {
+      alist = bubbleSort.sort(alist, swap)
+      return this.getData()
+    },
+    selectionSort () {
+      alist = selectionSort.sort(alist, swap)
+      return this.getData()
+    },
+    insertionSort () {
+      alist = insertionSort.sort(alist)
+      return this.getData()
+    },
+    quickSort () {
+      alist = quickMethod.sort(alist, swap)
+      return this.getData()
+    },
+    mergeSort () {
+      alist = mergeMethod.sort(alist)
+      return this.getData()
+    },
+    getData,
+    display
+  }
+
   exports.sort = function sort (args) {
     alist = args
-    return {
-      bubbleSort () {
-        alist = bubbleSort.sort(alist, swap)
-        return this.getData()
-      },
-      selectionSort () {
-        alist = selectionSort.sort(alist, swap)
-        return this.getData()
-      },
-      insertionSort () {
-        alist = insertionSort.sort(alist)
-        return this.getData()
-      },
-      quickSort () {
-        alist = quickMethod.sort(alist, swap)
-        return this.getData()
-      },
-      mergeSort () {
-        alist = mergeMethod.sort(alist)
-        return this.getData()
-      },
-      getData,
-      display
-    }
+    Object.assign(this, methods)
+    return this
   }
 }((typeof module.exports !== undefined) ? module.exports : window))

12-chapter-Sorting-Algorithms/sort-module.js

@@ -0,0 +1,60 @@
+const {sort} = require('./sort-module')
+
+const nsTime = (hrtime) => hrtime[0] * 1e9 + hrtime[1]
+
+function setData (numElements = 100) {
+  let dataStore = []
+  for (let i = 0; i < numElements; i++) {
+    dataStore[i] = Math.floor(Math.random() * (numElements + 1))
+  }
+  return dataStore
+}
+
+let basic = 50
+
+test (`bubbleSort test with ${basic} elements`, assert => {
+  let start = process.hrtime()
+  let dataStore = setData(basic)
+  let sorted = sort(dataStore).bubbleSort()
+  let end = process.hrtime(start)
+
+  assert.equal(dataStore.sort(), sorted, `Elapsed time on ${basic} elements is: ${nsTime(end) / 1e9} seconds.`)
+})
+
+test (`selectionSort test with ${basic} elements`, assert => {
+  let start = process.hrtime()
+  let dataStore = setData(basic)
+  let sorted = sort(dataStore).selectionSort()
+  let end = process.hrtime(start)
+
+  assert.equal(dataStore.sort(), sorted, `Elapsed time on ${basic} elements is: ${nsTime(end) / 1e9} seconds.`)
+})
+
+test (`insertionSort test with ${basic} elements`, assert => {
+  let start = process.hrtime()
+  let dataStore = setData(basic)
+  let sorted = sort(dataStore).insertionSort()
+  let end = process.hrtime(start)
+
+  assert.equal(dataStore.sort(), sorted, `Elapsed time on ${basic} elements is: ${nsTime(end) / 1e9} seconds.`)
+})
+
+let advance = 1000
+
+test (`mergeSort test with ${advance} elements`, assert => {
+  let start = process.hrtime()
+  let dataStore = setData(advance)
+  let sorted = sort(dataStore).mergeSort()
+  let end = process.hrtime(start)
+
+  assert.equal(dataStore.sort(), sorted, `Elapsed time on ${advance} elements is: ${nsTime(end) / 1e9} seconds.`)
+})
+
+test (`quickSort test with ${advance} elements`, assert => {
+  let start = process.hrtime()
+  let dataStore = setData(advance)
+  let sorted = sort(dataStore).quickSort()
+  let end = process.hrtime(start)
+
+  assert.equal(dataStore.sort(), sorted, `Elapsed time on ${advance} elements is: ${nsTime(end) / 1e9} seconds.`)
+})

12-chapter-Sorting-Algorithms/test.js

@@ -0,0 +1,4 @@
+(function (exports) {
+  const search = require('./search-module')
+  Object.assign(exports, {search})
+}((typeof module.exports !== undefined) ? module.exports : window))

13-chapter-Searching-Algorithms/13-chapter-Searching-Algorithms.js

@@ -1,4 +1,13 @@
-# Search Algorithms
+# Search Algorithms with ES6
+
+### Code Examples
+
+- [Sequential/Binary Search example](./search-module.js)
+- [JavaScript built-in findIndex(), find()](../03-chapter-List.js)
+- [Binary Search Tree Searches](../10-chapter-Binary-Trees.js)
+- [Depth/Breadth First Search](../11-chapter-2-adjecency-list-Graphs.js)
+
+### Description
 
 There are two ways to search for data in a list: sequential search and binary search. A sequential search is used when the items in a list are in random order; a binary search is used when the items in a list are in sorted order. Binary search is the more efficient algorithm, but you also have to take into account the extra time it takes to sort the data set before being able to search it for a value.
 
@@ -62,12 +71,6 @@ Applications:
 - Used in artificial intelligence to build bots, for instance a chess bot
 - Finding shortest path between two cities in a map and many other such applications
 
-### Code Examples
-
-- [JavaScript built-in findIndex(), find()](../03-chapter-List.js)
-- [Sequential/Binary Search example](./13-chapter-Searching-Algorithms.js)
-- [Binary Search Tree Searches](../10-chapter-Binary-Trees.js)
-- [Depth/Breadth First Search](../11-chapter-2-adjecency-list-Graphs.js)
 
 #### Resources