- implement Selection Sort algorithm

Author: Isaac Ramirez

README.md

@@ -61,7 +61,7 @@ _For a list similar to the book site see this [algorithms list](/docs/algorithms
 
 **Algorithms:**
 
-> TODO
+* [Selection Sort - p.249](/src/algorithms/selection-sort/selection-sort.js)
 
 **ADTs:**
 

docs/algorithms-list.md

@@ -50,7 +50,7 @@ Every algorithm or ADT has a link pointing to the original Java implementation a
 * Insertion | js | java |
 * InsertionX | js | java |
 * BinaryInsertion | js | java |
-* Selection | js | java |
+* Selection | [js](/src/algorithms/selection-sort/selection-sort.js) | [java](https://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/Selection.java.html) |
 * Shell | js | java |
 * Merge | js | java |
 * MergeBU | js | java |

src/algorithms/index.js

@@ -3,6 +3,7 @@ module.exports = {
   DijkstraEvaluate: require('./dijkstra-two-stack/dijkstra-two-stack'),
   Euclidean: require('./euclidean/euclidean'),
   LinearSearch: require('./linear-search/linear-search'),
+  SelectionSort: require('./selection-sort/selection-sort'),
   ThreeSum: require('./three-sum/three-sum'),
   ThreeSumFast: require('./three-sum-fast/three-sum-fast'),
   TwoSumFast: require('./two-sum-fast/two-sum-fast'),

src/algorithms/selection-sort/selection-sort.client.js

@@ -0,0 +1,46 @@
+const { StdIn } = require('../../libs')
+const Selection = require('./selection-sort')
+
+/**
+ * SelectionSortClient
+ * @classdesc Selection Sort Test Client.
+ * @see p. 245
+ */
+class SelectionSortClient {
+  /**
+   * Runs the Selection Sort Algorithm
+   * with the input provided.
+   * @example <caption>Tiny Example</caption>
+   * ```sh
+   * $ node selection-sort.client.js < ~/algs4-data/tiny.txt
+   * A E E L M O P R S T X
+   * ```
+   * @example <caption>Words3 Example</caption>
+   * ```sh
+   * $ node selection-sort.client.js < ~/algs4-data/words3.txt
+   *  all bad bed bug dad ... yes yet zoo
+   * ```
+   */
+  static main () {
+    let array = []
+
+    // read all strings from standard input.
+    StdIn.read()
+      .on('line', line => {
+        array = array.concat(line.split(' '))
+      })
+      .on('close', () => {
+        Selection.sort(array)
+
+        if (!Selection.isSorted(array)) {
+          throw new Error('array is NOT sorted')
+        }
+
+        Selection.show(array)
+      })
+  }
+}
+
+// Execution
+// ==============================
+SelectionSortClient.main()

src/algorithms/selection-sort/selection-sort.js

@@ -0,0 +1,105 @@
+const { StdOut } = require('../../libs')
+
+/**
+ * A default comparing function that
+ * returns -1 when `a` is less than `b`,
+ * returns 1 when `a` is greater than `b` or
+ * returns 0 when `a` is equal to `b`.
+ * @param {*} a Comparable object `a`
+ * @param {*} b Comparable object `b`
+ */
+const defaultComparator = (a, b) => {
+  if (a === b) return 0
+
+  return a < b ? -1 : 1
+}
+
+/**
+ * Selection
+ * @classdesc Selection Sort Algorithm.
+ * @see p. 245, 249
+ * @see {@link https://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/Selection.java.html}
+ */
+class Selection {
+  /**
+   * Returns whether `a` is less than `b`
+   * based on a comparing function.
+   * @param {*} a Comparable object `a`
+   * @param {*} b Comparable object `b`
+   * @param {function} comparator A comparing function that
+   * returns -1 when `a` is less than `b`,
+   * returns 1 when `a` is greater than `b` or
+   * returns 0 when `a` is equal to `b`.
+   */
+  static less (a, b, comparator = defaultComparator) {
+    return comparator(a, b) < 0
+  }
+
+  /**
+   * Interchanges the values located in indexes `i` and `j`
+   * for the given `array`.
+   * @param {[*]} array Array of values.
+   * @param {number} i Index 1
+   * @param {number} j Index 2
+   */
+  static exchange (array, i, j) {
+    const temp = array[i]
+
+    array[i] = array[j]
+    array[j] = temp
+  }
+
+  /**
+   * Returns `true` if the provided array is sorted,
+   * `false` otherwise.
+   * @param {[*]} array Array of values
+   * @param {function} comparator A comparing function that
+   * returns -1 when `a` is less than `b`,
+   * returns 1 when `a` is greater than `b` or
+   * returns 0 when `a` is equal to `b`.
+   */
+  static isSorted (array, comparator = defaultComparator) {
+    for (let i = 1; i < array.length; i++) {
+      if (Selection.less(array[i], array[i - 1], comparator)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  /**
+   * A function that prints to the StdOut
+   * the contents of the `array` provided.
+   * @param {[*]} array Array of values.
+   */
+  static show (array) {
+    StdOut.println(array.join(' '))
+  }
+
+  /**
+   * Sorts the `array` using the Selection Sort algorithm.
+   * @param {[*]} array Array of values.
+   * @param {*} comparator A comparing function that
+   * returns -1 when `a` is less than `b`,
+   * returns 1 when `a` is greater than `b` or
+   * returns 0 when `a` is equal to `b`.
+   */
+  static sort (array, comparator = defaultComparator) {
+    const n = array.length
+
+    for (let i = 0; i < n; i++) {
+      let min = i
+
+      for (let j = i + 1; j < n; j++) {
+        if (Selection.less(array[j], array[min], comparator)) {
+          min = j
+        }
+      }
+
+      Selection.exchange(array, i, min)
+    }
+  }
+}
+
+module.exports = Selection

src/algorithms/selection-sort/selection-sort.spec.js

@@ -0,0 +1,134 @@
+const Selection = require('./selection-sort')
+const { newArrayOf } = require('../../utils')
+const { StdRandom } = require('../../libs')
+
+const comparator = (a, b) => {
+  if (a < b) return -1
+  else if (a > b) return 1
+  return 0
+}
+
+describe('Unit Tests: Selection Sort Algorithm', () => {
+  beforeEach(() => {
+    this.orderedArray = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    this.reversedArray = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
+    this.unorderedArray = [0, 9, 5, 2, 1, 8, 7, 6, 4, 3]
+  })
+
+  describe('static less method', () => {
+    it('should return true if a is less than b', () => {
+      const a = 1
+      const b = 2
+
+      expect(Selection.less(a, b, comparator)).toBe(true)
+    })
+
+    it('should return false if a is greater than b', () => {
+      const a = 2
+      const b = 1
+
+      expect(Selection.less(a, b, comparator)).toBe(false)
+    })
+
+    it('should return false if a is equal to b', () => {
+      const a = 1
+      const b = 1
+
+      expect(Selection.less(a, b, comparator)).toBe(false)
+    })
+
+    it('should have a defaultComparator function', () => {
+      expect(Selection.less(1, 10)).toBe(true)
+      expect(Selection.less(1, 1)).toBe(false)
+      expect(Selection.less(10, 1)).toBe(false)
+    })
+  })
+
+  describe('static exchange method', () => {
+    it('should interchange the values of the two given indexes in the array', () => {
+      const array = [5, 6, 7]
+      const expectedArray = [7, 6, 5]
+
+      Selection.exchange(array, 0, 2)
+
+      expect(array).toEqual(expectedArray)
+    })
+  })
+
+  describe('static isSorted method', () => {
+    it('should return true if an array is sorted', () => {
+      expect(Selection.isSorted(this.orderedArray)).toBe(true)
+    })
+
+    it('should return false if the array is not sorted', () => {
+      expect(Selection.isSorted(this.unorderedArray)).toBe(false)
+      expect(Selection.isSorted(this.reversedArray)).toBe(false)
+    })
+
+    it('should accept a comparator function', () => {
+      const orderedArray = ['A', 'B', 'C']
+      const unorderedArray = ['Z', 'X', 'Y']
+
+      expect(Selection.isSorted(orderedArray, comparator)).toBe(true)
+      expect(Selection.isSorted(unorderedArray, comparator)).toBe(false)
+    })
+
+    it('should return true for a sorted big array', () => {
+      const n = 1000000 // a million!
+      const array = newArrayOf(n, i => i) // from 0 to 999999
+
+      expect(Selection.isSorted(array)).toBeTrue()
+    })
+
+    it('should return false for a random big array', () => {
+      const n = 1000000 // a million!
+      const array = newArrayOf(n, i => i) // from 0 to 999999
+      array[array.length - 1] = 0 // change last number to be 0
+
+      expect(Selection.isSorted(array)).toBeFalse()
+    })
+  })
+
+  describe('static sort method', () => {
+    it('should be a function', () => {
+      // I could test the call to StdOut, but I don't want to.
+      expect(Selection.show).toBeInstanceOf(Function)
+    })
+  })
+
+  describe('static sort method', () => {
+    it('should sort a unordered array', () => {
+      const expectedArray = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+      Selection.sort(this.unorderedArray)
+
+      expect(this.unorderedArray).toEqual(expectedArray)
+    })
+
+    it('should sort an ordered array', () => {
+      const expectedArray = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+      Selection.sort(this.orderedArray)
+
+      expect(this.orderedArray).toEqual(expectedArray)
+    })
+
+    it('should sort a reversed array', () => {
+      const expectedArray = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+      Selection.sort(this.reversedArray)
+
+      expect(this.reversedArray).toEqual(expectedArray)
+    })
+
+    it('should sort a small random array', () => {
+      // considering that Selection Sort is slow...
+      const n = 1000 // a thousand
+      const array = newArrayOf(n, () => StdRandom.uniform(n))
+
+      Selection.sort(array)
+
+      expect(Selection.isSorted(array)).toBeTrue()
+    })
+  })
+})