style: Fixed most styles (according to standardjs)

Sorts/GnomeSort.js

@@ -23,7 +23,7 @@ function gnomeSort (items) {
 
 // Implementation of gnomeSort
 
-var ar = [5, 6, 7, 8, 1, 2, 12, 14]
+const ar = [5, 6, 7, 8, 1, 2, 12, 14]
 // Array before Sort
 console.log(ar)
 gnomeSort(ar)

Sorts/HeapSort.js

@@ -50,7 +50,7 @@ function heapSort (items) {
 
 // Implementation of heapSort
 
-var ar = [5, 6, 7, 8, 1, 2, 12, 14]
+const ar = [5, 6, 7, 8, 1, 2, 12, 14]
 // Array before Sort
 console.log(ar)
 heapSort(ar)

Sorts/InsertionSort.js

@@ -5,9 +5,9 @@
 * the correct position and expand sorted part one element at a time.
 */
 function insertionSort (unsortedList) {
-  var len = unsortedList.length
-  for (var i = 1; i < len; i++) {
-    var tmp = unsortedList[i] // Copy of the current element.
+  const len = unsortedList.length
+  for (let i = 1; i < len; i++) {
+    const tmp = unsortedList[i] // Copy of the current element.
     /* Check through the sorted part and compare with the number in tmp. If large, shift the number */
     for (var j = i - 1; j >= 0 && (unsortedList[j] > tmp); j--) {
       // Shift the number
@@ -19,6 +19,6 @@ function insertionSort (unsortedList) {
   }
 }
 
-var arr = [5, 3, 1, 2, 4, 8, 3, 8]
+const arr = [5, 3, 1, 2, 4, 8, 3, 8]
 insertionSort(arr)
 console.log(arr)

Sorts/IntroSort.js

@@ -28,12 +28,12 @@ function introsort (array, compare) {
    *  0 if a is equal to b
    *  1 if a greater than b
    */
-  var defaultComparator = function (x, y) {
+  const defaultComparator = function (x, y) {
     if (x === undefined && y === undefined) return 0
     if (x === undefined) return 1
     if (y === undefined) return -1
-    var xString = toString(x)
-    var yString = toString(y)
+    const xString = toString(x)
+    const yString = toString(y)
     if (xString < yString) return -1
     if (xString > yString) return 1
     return 0
@@ -75,8 +75,8 @@ function introsort (array, compare) {
    * [IIFE](https://en.wikipedia.org/wiki/Immediately_invoked_function_expression)
    */
   return (function (array, comparator) {
-    var swap = function (index1, index2) {
-      var temp = array[index1]
+    const swap = function (index1, index2) {
+      const temp = array[index1]
       array[index1] = array[index2]
       array[index2] = temp
     }
@@ -85,14 +85,14 @@ function introsort (array, compare) {
      * If the length of array is less than
      * this then we simply perform insertion sort
      */
-    var THRESHOLD = 16
+    const THRESHOLD = 16
     /**
      * @constant TUNEMAXDEPTH
      * Constant usec to increase or decrease value
      * of maxDepth
      */
-    var TUNEMAXDEPTH = 1
-    var len = array.length
+    const TUNEMAXDEPTH = 1
+    const len = array.length
     /**
      * Return if array is only of length 1
      * Array of size 1 is always sorted
@@ -104,7 +104,7 @@ function introsort (array, compare) {
      * Calculate maxDepth = log2(len)
      * Taken from implementation in stdc++
      */
-    var maxDepth = Math.floor(Math.log2(len)) * TUNEMAXDEPTH
+    const maxDepth = Math.floor(Math.log2(len)) * TUNEMAXDEPTH
     /**
      * The very first call to quicksort
      * this initiates sort routine
@@ -133,7 +133,7 @@ function introsort (array, compare) {
         heapSort(start, last)
         return
       }
-      var pivot = (last + start) >> 1
+      let pivot = (last + start) >> 1
       pivot = partition(start, last, pivot)
       quickSort(start, pivot, depth - 1)
       quickSort(pivot + 1, last, depth - 1)
@@ -148,8 +148,8 @@ function introsort (array, compare) {
     function partition (start, last, pivot) {
       swap(start, pivot)
       pivot = start
-      var lo = start
-      var hi = last
+      let lo = start
+      let hi = last
       while (true) {
         lo++
         while (comparator(array[lo], array[pivot]) <= 0 && lo !== last) {
@@ -175,7 +175,7 @@ function introsort (array, compare) {
      * @param {Number} last  one more than last index of array to be sorted
      */
     function insertionSort (start, last) {
-      var i, j
+      let i, j
       for (i = start + 1; i < last; i++) {
         j = i - 1
         while (j >= 0 && comparator(array[j], array[j + 1]) > 0) {
@@ -192,7 +192,7 @@ function introsort (array, compare) {
      * @param {Number} last  one more than last index of array to be sorted
      */
     function heapSort (start, last) {
-      var x = (last + start) >> 1
+      let x = (last + start) >> 1
       while (x - start >= 0) {
         heapify(x, start, last)
         x--
@@ -211,8 +211,8 @@ function introsort (array, compare) {
      * @param {Number} last  one more than last index of segment that cur belongs to
      */
     function heapify (cur, start, last) {
-      var size = last - start
-      var max, lt, rt
+      const size = last - start
+      let max, lt, rt
       cur = cur - start
       while (true) {
         max = cur
@@ -250,9 +250,9 @@ function introsort (array, compare) {
 (function demo () {
   const data = []
   const size = 1000000
-  var i = 0
-  var temp
-  var c = function (a, b) {
+  let i = 0
+  let temp
+  const c = function (a, b) {
     return a - b
   }
   for (i = 0; i < size; i++) {
@@ -260,7 +260,7 @@ function introsort (array, compare) {
     data.push(temp)
   }
   introsort(data, c)
-  var faulty = false
+  let faulty = false
   for (i = 1; i < size; i++) {
     if (data[i] < data[i - 1]) {
       faulty = true
@@ -283,8 +283,8 @@ function introsort (array, compare) {
   const data = []
   const data2 = []
   const size = 1000000
-  var i = 0
-  var temp
+  let i = 0
+  let temp
   for (i = 0; i < size; i++) {
     temp = Math.random() * Number.MAX_SAFE_INTEGER
     data.push(temp)
@@ -292,7 +292,7 @@ function introsort (array, compare) {
   }
   introsort(data)
   data2.sort()
-  var faulty = false
+  let faulty = false
   for (i = 1; i < size; i++) {
     if (data[i] !== data2[i]) {
       faulty = true

Sorts/MergeSort.js

@@ -35,7 +35,7 @@
 */
 
 function merge (list1, list2) {
-  var results = []
+  const results = []
 
   while (list1.length && list2.length) {
     if (list1[0] <= list2[0]) {
@@ -55,15 +55,15 @@ function merge (list1, list2) {
 function mergeSort (list) {
   if (list.length < 2) return list
 
-  var listHalf = Math.floor(list.length / 2)
-  var subList1 = list.slice(0, listHalf)
-  var subList2 = list.slice(listHalf, list.length)
+  const listHalf = Math.floor(list.length / 2)
+  const subList1 = list.slice(0, listHalf)
+  const subList2 = list.slice(listHalf, list.length)
 
   return merge(mergeSort(subList1), mergeSort(subList2))
 }
 
 // Merge Sort Example
-var unsortedArray = [10, 5, 3, 8, 2, 6, 4, 7, 9, 1]
-var sortedArray = mergeSort(unsortedArray)
+const unsortedArray = [10, 5, 3, 8, 2, 6, 4, 7, 9, 1]
+const sortedArray = mergeSort(unsortedArray)
 
 console.log('Before:', unsortedArray, 'After:', sortedArray)

Sorts/QuickSort.js

@@ -17,16 +17,16 @@
 */
 
 function quickSort (items) {
-  var length = items.length
+  const length = items.length
 
   if (length <= 1) {
     return items
   }
-  var PIVOT = items[0]
-  var GREATER = []
-  var LESSER = []
+  const PIVOT = items[0]
+  const GREATER = []
+  const LESSER = []
 
-  for (var i = 1; i < length; i++) {
+  for (let i = 1; i < length; i++) {
     if (items[i] > PIVOT) {
       GREATER.push(items[i])
     } else {
@@ -34,7 +34,7 @@ function quickSort (items) {
     }
   }
 
-  var sorted = quickSort(LESSER)
+  let sorted = quickSort(LESSER)
   sorted.push(PIVOT)
   sorted = sorted.concat(quickSort(GREATER))
 
@@ -43,7 +43,7 @@ function quickSort (items) {
 
 // Implementation of quick sort
 
-var ar = [0, 5, 3, 2, 2]
+let ar = [0, 5, 3, 2, 2]
 // Array before Sort
 console.log(ar)
 ar = quickSort(ar)

Sorts/RadixSort.js

@@ -10,29 +10,29 @@ function radixSort (items, RADIX) {
     RADIX = 10
   }
 
-  var maxLength = false
-  var placement = 1
+  let maxLength = false
+  let placement = 1
 
   while (!maxLength) {
     maxLength = true
-    var buckets = []
+    const buckets = []
 
-    for (var i = 0; i < RADIX; i++) {
+    for (let i = 0; i < RADIX; i++) {
       buckets.push([])
     }
 
-    for (var j = 0; j < items.length; j++) {
-      var tmp = items[j] / placement
+    for (let j = 0; j < items.length; j++) {
+      const tmp = items[j] / placement
       buckets[Math.floor(tmp % RADIX)].push(items[j])
       if (maxLength && tmp > 0) {
         maxLength = false
       }
     }
 
-    var a = 0
-    for (var b = 0; b < RADIX; b++) {
-      var buck = buckets[b]
-      for (var k = 0; k < buck.length; k++) {
+    let a = 0
+    for (let b = 0; b < RADIX; b++) {
+      const buck = buckets[b]
+      for (let k = 0; k < buck.length; k++) {
         items[a] = buck[k]
         a++
       }
@@ -44,7 +44,7 @@ function radixSort (items, RADIX) {
 
 // Implementation of radixSort
 
-var ar = [5, 6, 7, 8, 1, 2, 12, 14]
+const ar = [5, 6, 7, 8, 1, 2, 12, 14]
 // Array before Sort
 console.log(ar)
 radixSort(ar)

Sorts/SelectionSort.test.js

@@ -2,7 +2,7 @@ import { selectionSort } from './SelectionSort'
 
 describe('selectionSort', () => {
   it('expects to return the array sorted in ascending order', () => {
-    var toSort = [5, 6, 7, 8, 1, 2, 12, 14]
+    const toSort = [5, 6, 7, 8, 1, 2, 12, 14]
     const expected = [1, 2, 5, 6, 7, 8, 12, 14]
 
     expect(selectionSort(toSort)).toEqual(expected)

Sorts/ShellSort.js

@@ -4,16 +4,16 @@
  *
  */
 function shellSort (items) {
-  var interval = 1
+  let interval = 1
 
   while (interval < items.length / 3) {
     interval = interval * 3 + 1
   }
 
   while (interval > 0) {
-    for (var outer = interval; outer < items.length; outer++) {
-      var value = items[outer]
-      var inner = outer
+    for (let outer = interval; outer < items.length; outer++) {
+      const value = items[outer]
+      let inner = outer
 
       while (inner > interval - 1 && items[inner - interval] >= value) {
         items[inner] = items[inner - interval]
@@ -28,7 +28,7 @@ function shellSort (items) {
 
 // Implementation of shellSort
 
-var ar = [5, 6, 7, 8, 1, 2, 12, 14]
+const ar = [5, 6, 7, 8, 1, 2, 12, 14]
 // Array before Sort
 console.log(ar)
 shellSort(ar)

Sorts/TopologicalSort.js

@@ -1,10 +1,10 @@
 
 function TopologicalSorter () {
-  var graph = {}
-  var isVisitedNode
-  var finishTimeCount
-  var finishingTimeList
-  var nextNode
+  const graph = {}
+  let isVisitedNode
+  let finishTimeCount
+  let finishingTimeList
+  let nextNode
 
   this.addOrder = function (nodeA, nodeB) {
     nodeA = String(nodeA)
@@ -18,7 +18,7 @@ function TopologicalSorter () {
     finishTimeCount = 0
     finishingTimeList = []
 
-    for (var node in graph) {
+    for (const node in graph) {
       if (Object.prototype.hasOwnProperty.call(graph, node) && !isVisitedNode[node]) {
         dfsTraverse(node)
       }
@@ -34,7 +34,7 @@ function TopologicalSorter () {
   function dfsTraverse (node) {
     isVisitedNode[node] = true
     if (graph[node]) {
-      for (var i = 0; i < graph[node].length; i++) {
+      for (let i = 0; i < graph[node].length; i++) {
         nextNode = graph[node][i]
         if (isVisitedNode[nextNode]) continue
         dfsTraverse(nextNode)
@@ -49,7 +49,7 @@ function TopologicalSorter () {
 }
 
 /* TEST */
-var topoSorter = new TopologicalSorter()
+const topoSorter = new TopologicalSorter()
 topoSorter.addOrder(5, 2)
 topoSorter.addOrder(5, 0)
 topoSorter.addOrder(4, 0)

Sorts/WiggleSort.js

@@ -18,7 +18,7 @@ Array.prototype.wiggleSort = function () {
 
 // Implementation of wiggle sort
 
-var arr = [3, 5, 2, 1, 6, 4]
+const arr = [3, 5, 2, 1, 6, 4]
 // Array before Wiggle Sort
 console.log(arr) // [3, 5, 2, 1, 6, 4]