src/algorithms/sorting/bucket-sort/BucketSort.js

@@ -0,0 +1,69 @@
+// this code utilizes my own hash_sort
+import Sort from '../Sort';
+
+export default class BucketSort extends Sort {
+  /**
+   * @param {number[]} array
+   * @description BucketSort is ideal for an even distribution.
+   */
+
+  // InsertionSort to be used within bucket sort
+  insertionSort(array) {
+    const noReassign = array;
+    const size = noReassign.length;
+    for (let i = 1; i < size; i += 1) {
+      const temp = noReassign[i];
+      for (let j = i - 1; j >= 0 && noReassign[j] > temp; j -= 1) {
+        noReassign[j + 1] = noReassign[j];
+        noReassign[j + 1] = temp;
+      }
+    }
+
+    return noReassign;
+  }
+
+  // Implement bucket sort
+  sort(array, bucketSize = 1) {
+    // Declaring vars
+    const noReassign = array;
+    let i;
+    let minValue = noReassign[0];
+    let maxValue = noReassign[0];
+    if (noReassign.length === 0) {
+      return noReassign;
+    }
+    // Setting min and max values
+    noReassign.forEach((currentVal) => {
+      if (currentVal < minValue) {
+        minValue = currentVal;
+      } else if (currentVal > maxValue) {
+        maxValue = currentVal;
+      }
+    });
+
+    // Initializing buckets
+    const bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
+    const allBuckets = new Array(bucketCount);
+
+    for (i = 0; i < allBuckets.length; i += 1) {
+      allBuckets[i] = [];
+    }
+
+    // Pushing values to buckets
+    noReassign.forEach((element) => {
+      allBuckets[Math.floor((element - minValue) / bucketSize)].push(element);
+    });
+
+    // Sorting buckets
+    noReassign.length = 0;
+
+    allBuckets.forEach((bucket) => {
+      this.insertionSort(bucket);
+      bucket.forEach((element) => {
+        noReassign.push(element);
+      });
+    });
+
+    return noReassign;
+  }
+}

src/algorithms/sorting/bucket-sort/README.md

@@ -0,0 +1,37 @@
+# Bucket Sort
+
+**Bucket sort, or bin sort**, is a sorting algorithm that works by distributing the elements of an array into a number of buckets. Each bucket is then sorted individually, either using a different sorting algorithm, or by recursively applying the bucket sorting algorithm. It is a distribution sort, a generalization of pigeonhole sort, and is a cousin of radix sort in the most-to-least significant digit flavor. Bucket sort can be implemented with comparisons and therefore can also be considered a comparison sort algorithm. The computational complexity depends on the algorithm used to sort each bucket, the number of buckets to use, and whether the input is uniformly distributed.
+
+## Algorithm
+
+**Phase I**
+
+1. Set up an array of initially empty "buckets".
+2. Scatter: Go over the original array, putting each object in its bucket.
+
+![Bucket Sort](https://upload.wikimedia.org/wikipedia/commons/thumb/6/61/Bucket_sort_1.svg/311px-Bucket_sort_1.svg.png)
+
+**Phase II**
+
+3. Sort each non-empty bucket.
+**or**
+3. recurse and BucketSort the buckets again
+
+![Bucket Sort](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e3/Bucket_sort_2.svg/311px-Bucket_sort_2.svg.png)
+
+**Phase 3**
+
+4. Gather: Visit the buckets in order and put all elements back into the original array.
+
+
+## Complexity
+
+| Name                  | Best            | Average             | Worst               | Memory    | Stable  
+| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **Bucket Sort**     | n + k           | n + k              | n<sup>2</sup>              | n    | Yes       
+
+## References
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Counting_sort)
+- [BigOCheatSheet](http://bigocheatsheet.com)
+

src/algorithms/sorting/bucket-sort/_test_/BucketSort.test.js

@@ -0,0 +1,15 @@
+import BucketSort from '../BucketSort';
+import {
+  SortTester,
+} from '../../SortTester';
+
+
+describe('BucketSort', () => {
+  it('should sort array', () => {
+    SortTester.testSort(BucketSort);
+  });
+
+  it('should sort negative numbers', () => {
+    SortTester.testNegativeNumbersSort(BucketSort);
+  });
+});