feat: implements counting sort algorithm

Author: thawkin3

README.md

@@ -68,7 +68,7 @@ Demos can be found at: http://tylerhawkins.info/js-data-structures-and-algorithm
 ### Sorting
 
 - [Bubble Sort](src/algorithms/sort/bubble-sort/src/bubble-sort.js)
-- Counting Sort (TODO)
+- [Counting Sort](src/algorithms/sort/counting-sort/src/counting-sort.js)
 - Heap Sort (TODO)
 - [Insertion Sort](src/algorithms/sort/insertion-sort/src/insertion-sort.js)
 - [Merge Sort](src/algorithms/sort/merge-sort/src/merge-sort.js)

src/algorithms/sort/additional-demos/sort-performance-comparison-test.demo.js

@@ -1,6 +1,7 @@
 import React, { Component } from 'react'
 import './sort-performance-comparison-test.demo.css'
 import { bubbleSort } from '../bubble-sort/src/bubble-sort'
+import { countingSort } from '../counting-sort/src/counting-sort'
 import { insertionSort } from '../insertion-sort/src/insertion-sort'
 import { mergeSort } from '../merge-sort/src/merge-sort'
 import { quickSort } from '../quick-sort/src/quick-sort'
@@ -149,6 +150,11 @@ class SortPerformanceComparisonTest extends Component {
     bubbleSort(initialArrayCopy)
     const endTimeForBubbleSort = performance.now()
 
+    initialArrayCopy = [...storedArrays[arrayKey].initialArray]
+    const startTimeForCountingSort = performance.now()
+    countingSort(initialArrayCopy)
+    const endTimeForCountingSort = performance.now()
+
     initialArrayCopy = [...storedArrays[arrayKey].initialArray]
     const startTimeForInsertionSort = performance.now()
     insertionSort(initialArrayCopy)
@@ -177,6 +183,7 @@ class SortPerformanceComparisonTest extends Component {
           ...prevState.storedArrays[arrayKey],
           timeTaken: {
             bubbleSort: endTimeForBubbleSort - startTimeForBubbleSort,
+            countingSort: endTimeForCountingSort - startTimeForCountingSort,
             insertionSort: endTimeForInsertionSort - startTimeForInsertionSort,
             mergeSort: endTimeForMergeSort - startTimeForMergeSort,
             quickSort: endTimeForQuickSort - startTimeForQuickSort,
@@ -268,6 +275,22 @@ class SortPerformanceComparisonTest extends Component {
                 seconds).
               </div>
               <hr />
+              <div>
+                <h3>Counting Sort </h3> took{' '}
+                <b>
+                  {storedArrays[
+                    currentResultKey
+                  ].timeTaken.countingSort.toFixed(3)}
+                </b>{' '}
+                milliseconds (or{' '}
+                <b>
+                  {(
+                    storedArrays[currentResultKey].timeTaken.countingSort / 1000
+                  ).toFixed(6)}
+                </b>{' '}
+                seconds).
+              </div>
+              <hr />
               <div>
                 <h3>Insertion Sort </h3> took{' '}
                 <b>

src/algorithms/sort/counting-sort/demo/counting-sort.demo.js

@@ -0,0 +1,14 @@
+import React from 'react'
+import { countingSort } from '../src/counting-sort'
+import { SortPerformanceTest } from '../../demo-utils/sort-performance-test.demo'
+
+export default {
+  title: 'Algorithms/Sort/Counting Sort',
+}
+
+export const countingSortPerformanceTest = () => (
+  <SortPerformanceTest
+    sortMethodName="Counting Sort"
+    sortMethod={countingSort}
+  />
+)

src/algorithms/sort/counting-sort/src/counting-sort.js

@@ -0,0 +1,76 @@
+/**
+ * Counting Sort
+ *
+ * Compares each pair of adjacent items and swaps them if they are in the wrong order
+ * Continues looping through the array until no more swaps are needed
+ * Not appropriate for large unsorted data sets
+ *
+ * Best case performance: Ω(n + k) (always loops through the input array, count array, and output array)
+ * Average case performance: θ(n + k) (always loops through the input array, count array, and output array)
+ * Worst case performance: O(n + k) (always loops through the input array, count array, and output array)
+ *
+ * Space required: O(n + k)
+ */
+
+export const countingSort = (arr, minValue, maxValue, showLogs) => {
+  const sortedArr = []
+  const countArr = []
+  let min = minValue
+  let max = maxValue
+
+  /* istanbul ignore next */
+  showLogs && console.log(`starting array: ${arr.join(' ')}`)
+
+  if (typeof min === 'undefined' || typeof max === 'undefined') {
+    /* istanbul ignore next */
+    showLogs && console.log('getting min and max values of the input array')
+
+    for (let i = 0; i < arr.length; i++) {
+      const currentElement = arr[i]
+
+      if (i === 0) {
+        min = currentElement
+        max = currentElement
+      }
+
+      if (currentElement < min) {
+        min = currentElement
+      }
+
+      if (currentElement > max) {
+        max = currentElement
+      }
+    }
+  }
+
+  /* istanbul ignore next */
+  showLogs && console.log(`min value: ${min}; max value: ${max}`)
+
+  const countRange = max - min + 1
+  for (let i = 0; i < countRange; i++) {
+    countArr.push(0)
+  }
+
+  /* istanbul ignore next */
+  showLogs && console.log(`initialized count array: ${countArr.join(' ')}`)
+
+  for (let i = 0; i < arr.length; i++) {
+    const currentElement = arr[i]
+    countArr[currentElement - min]++
+  }
+
+  /* istanbul ignore next */
+  showLogs && console.log(`populated count array: ${countArr.join(' ')}`)
+
+  for (let i = 0; i < countArr.length; i++) {
+    while (countArr[i] > 0) {
+      sortedArr.push(i + min)
+      countArr[i]--
+    }
+  }
+
+  /* istanbul ignore next */
+  showLogs && console.log(`sorted output array: ${sortedArr.join(' ')}`)
+
+  return sortedArr
+}

src/algorithms/sort/counting-sort/src/counting-sort.test.js

@@ -0,0 +1,137 @@
+import { countingSort } from './counting-sort'
+
+const showLogs = process.env.SHOW_LOGS === '1'
+
+describe('countingSort', () => {
+  describe('non-negative integers in the input array', () => {
+    it('correctly sorts an unsorted array', () => {
+      const arrayToSort = [3, 6, 2, 8, 9, 1, 4, 5, 7]
+      const expectedResult = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      expect(countingSort(arrayToSort, undefined, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+
+    it('correctly sorts a mostly sorted array', () => {
+      const arrayToSort = [1, 2, 9, 3, 4, 5, 6, 7, 8]
+      const expectedResult = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      expect(countingSort(arrayToSort, undefined, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+
+    it('correctly sorts an inversely sorted array', () => {
+      const arrayToSort = [9, 8, 7, 6, 5, 4, 3, 2, 1]
+      const expectedResult = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      expect(countingSort(arrayToSort, undefined, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+
+    it('correctly returns an already sorted array', () => {
+      const arrayToSort = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      const expectedResult = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      expect(countingSort(arrayToSort, undefined, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+
+    it('can handle an array with duplicates', () => {
+      const arrayToSort = [3, 6, 2, 8, 4, 4, 4, 4, 7]
+      const expectedResult = [2, 3, 4, 4, 4, 4, 6, 7, 8]
+      expect(countingSort(arrayToSort, undefined, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+
+    it('can handle an array with only one item', () => {
+      const arrayToSort = [1]
+      const expectedResult = [1]
+      expect(countingSort(arrayToSort, undefined, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+
+    it('can handle an empty array', () => {
+      const arrayToSort = []
+      const expectedResult = []
+      expect(countingSort(arrayToSort, undefined, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+  })
+
+  describe('negative integers in the input array', () => {
+    it('correctly sorts an unsorted array', () => {
+      const arrayToSort = [3, 6, 2, 8, -2, 9, 1, 4, -1, 5, 10, 0, 7]
+      const expectedResult = [-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+      expect(countingSort(arrayToSort, undefined, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+
+    it('correctly sorts a mostly sorted array', () => {
+      const arrayToSort = [-2, -1, 0, 1, 2, 9, 3, 4, 5, 6, 7, 8, 10]
+      const expectedResult = [-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+      expect(countingSort(arrayToSort, undefined, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+
+    it('correctly sorts an inversely sorted array', () => {
+      const arrayToSort = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2]
+      const expectedResult = [-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+      expect(countingSort(arrayToSort, undefined, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+
+    it('correctly returns an already sorted array', () => {
+      const arrayToSort = [-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+      const expectedResult = [-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+      expect(countingSort(arrayToSort, undefined, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+
+    it('can handle an array with duplicates', () => {
+      const arrayToSort = [3, 6, -1, -1, 2, 8, 4, 4, 10, 4, -1, 4, 7]
+      const expectedResult = [-1, -1, -1, 2, 3, 4, 4, 4, 4, 6, 7, 8, 10]
+      expect(countingSort(arrayToSort, undefined, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+
+    it('can handle an array with only one item', () => {
+      const arrayToSort = [-1]
+      const expectedResult = [-1]
+      expect(countingSort(arrayToSort, undefined, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+  })
+
+  describe('min and max value arguments', () => {
+    it('uses the provided minValue and maxValue arguments when provided', () => {
+      const arrayToSort = [3, 6, 2, 8, 9, 1, 4, 5, 7]
+      const expectedResult = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      expect(countingSort(arrayToSort, 1, 9, showLogs)).toEqual(expectedResult)
+    })
+
+    it('calculates the min and max if only the minValue argument is provided', () => {
+      const arrayToSort = [3, 6, 2, 8, 9, 1, 4, 5, 7]
+      const expectedResult = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      expect(countingSort(arrayToSort, 1, undefined, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+
+    it('calculates the min and max if only the maxValue argument is provided', () => {
+      const arrayToSort = [3, 6, 2, 8, 9, 1, 4, 5, 7]
+      const expectedResult = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      expect(countingSort(arrayToSort, undefined, 9, showLogs)).toEqual(
+        expectedResult
+      )
+    })
+  })
+})

src/main.js

@@ -18,6 +18,7 @@ export { union } from './algorithms/set/union/src/union'
 
 // Sort
 export { bubbleSort } from './algorithms/sort/bubble-sort/src/bubble-sort'
+export { countingSort } from './algorithms/sort/counting-sort/src/counting-sort'
 export { insertionSort } from './algorithms/sort/insertion-sort/src/insertion-sort'
 export { mergeSort } from './algorithms/sort/merge-sort/src/merge-sort'
 export { quickSort } from './algorithms/sort/quick-sort/src/quick-sort'