chore: Merge pull request TheAlgorithms#736 from charliejmoore/bucket-sort-tests

Bucket sort tests

Author: raklaptudirm

Sorts/BucketSort.js

@@ -1,5 +1,5 @@
 /*
-Wikipedia says: Bucket sort, or bin sort, is a sorting algorithm that works by distributing the
+[Wikipedia says](https://en.wikipedia.org/wiki/Bucket_sort#:~:text=Bucket%20sort%2C%20or%20bin%20sort,applying%20the%20bucket%20sorting%20algorithm.&text=Sort%20each%20non%2Dempty%20bucket.): 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, and is a cousin of radix sort in the most to least significant digit flavour.
@@ -11,6 +11,14 @@ Time Complexity of Solution:
 Best Case O(n); Average Case O(n); Worst Case O(n)
 
 */
+
+/**
+ * bucketSort returns an array of numbers sorted in increasing order.
+ *
+ * @param {number[]} list The array of numbers to be sorted.
+ * @param {number} size The size of the buckets used. If not provided, size will be 5.
+ * @return {number[]} An array of numbers sorted in increasing order.
+ */
 function bucketSort (list, size) {
   if (undefined === size) {
     size = 5
@@ -45,20 +53,12 @@ function bucketSort (list, size) {
   const sorted = []
   // now sort every bucket and merge it to the sorted list
   for (let iBucket = 0; iBucket < buckets.length; iBucket++) {
-    const arr = buckets[iBucket].sort()
+    const arr = buckets[iBucket].sort((a, b) => a - b)
     for (let iSorted = 0; iSorted < arr.length; iSorted++) {
       sorted.push(arr[iSorted])
     }
   }
   return sorted
 }
 
-// Testing
-const arrOriginal = [5, 6, 7, 8, 1, 2, 12, 14]
-// > bucketSort(arrOriginal)
-// [1, 2, 5, 6, 7, 8, 12, 14]
-// Array before Sort
-console.log(arrOriginal)
-const arrSorted = bucketSort(arrOriginal)
-// Array after sort
-console.log(arrSorted)
+export { bucketSort }

Sorts/test/BucketSort.test.js

@@ -0,0 +1,69 @@
+import { bucketSort } from '../BucketSort'
+
+describe('Tests for bucketSort function', () => {
+  it('should correctly sort an input list that is sorted backwards', () => {
+    const array = [5, 4, 3, 2, 1]
+    expect(bucketSort(array)).toEqual([1, 2, 3, 4, 5])
+  })
+
+  it('should correctly sort an input list that is unsorted', () => {
+    const array = [15, 24, 3, 2224, 1]
+    expect(bucketSort(array)).toEqual([1, 3, 15, 24, 2224])
+  })
+
+  describe('Variations of input array lengths', () => {
+    it('should return an empty list with the input list is an empty list', () => {
+      expect(bucketSort([])).toEqual([])
+    })
+
+    it('should correctly sort an input list of length 1', () => {
+      expect(bucketSort([100])).toEqual([100])
+    })
+
+    it('should correctly sort an input list of an odd length', () => {
+      expect(bucketSort([101, -10, 321])).toEqual([-10, 101, 321])
+    })
+
+    it('should correctly sort an input list of an even length', () => {
+      expect(bucketSort([40, 42, 56, 45, 12, 3])).toEqual([3, 12, 40, 42, 45, 56])
+    })
+  })
+
+  describe('Variations of input array elements', () => {
+    it('should correctly sort an input list that contains only positive numbers', () => {
+      expect(bucketSort([50, 33, 11, 2])).toEqual([2, 11, 33, 50])
+    })
+
+    it('should correctly sort an input list that contains only negative numbers', () => {
+      expect(bucketSort([-1, -21, -2, -35])).toEqual([-35, -21, -2, -1])
+    })
+
+    it('should correctly sort an input list that contains only a mix of positive and negative numbers', () => {
+      expect(bucketSort([-40, 42, 56, -45, 12, -3])).toEqual([-45, -40, -3, 12, 42, 56])
+    })
+
+    it('should correctly sort an input list that contains only whole numbers', () => {
+      expect(bucketSort([11, 3, 12, 4, -15])).toEqual([-15, 3, 4, 11, 12])
+    })
+
+    it('should correctly sort an input list that contains only decimal numbers', () => {
+      expect(bucketSort([1.0, 1.42, 2.56, 33.45, 13.12, 2.3])).toEqual([1.0, 1.42, 2.3, 2.56, 13.12, 33.45])
+    })
+
+    it('should correctly sort an input list that contains only a mix of whole and decimal', () => {
+      expect(bucketSort([32.40, 12.42, 56, 45, 12, 3])).toEqual([3, 12, 12.42, 32.40, 45, 56])
+    })
+
+    it('should correctly sort an input list that contains only fractional numbers', () => {
+      expect(bucketSort([0.98, 0.4259, 0.56, -0.456, -0.12, 0.322])).toEqual([-0.456, -0.12, 0.322, 0.4259, 0.56, 0.98])
+    })
+
+    it('should correctly sort an input list that contains only a mix of whole, decimal, and fractional', () => {
+      expect(bucketSort([-40, -0.222, 5.6, -4.5, 12, 0.333])).toEqual([-40, -4.5, -0.222, 0.333, 5.6, 12])
+    })
+
+    it('should correctly sort an input list that contains duplicates', () => {
+      expect(bucketSort([4, 3, 4, 2, 1, 2])).toEqual([1, 2, 2, 3, 4, 4])
+    })
+  })
+})