Bucket Sort Algorithm: Hacktober2023

pubspec.yaml

@@ -10,4 +10,4 @@ dev_dependencies:
   stack: ^0.2.1
 
 environment:
-  sdk: ">=2.10.0 <3.0.0"
+  sdk: ">=2.12.0 <3.0.0"

sort/bucket_sort.dart

@@ -0,0 +1,46 @@
+import 'dart:math';
+///This algorithm uses the bucket sort algorithm to sort a list of doubles.
+///The algorithm is as follows:
+///1. Find the maximum and minimum values in the list.
+///2. Create a list of buckets, where each bucket is a list of doubles.
+///3. For each value in the list, add it to the bucket corresponding to its index.
+///4. Sort each bucket.
+///5. Concatenate the buckets together.
+///The algorithm is O(n) in the best case, and O(n^2) in the worst case.
+///Source: https://en.wikipedia.org/wiki/Bucket_sort
+
+void bucketSort(List<double> arr) {
+  int n = arr.length;
+
+  if (n <= 1) return;
+
+  double maxVal = arr.reduce(max);
+  double minVal = arr.reduce(min);
+
+  List<List<double>> buckets = List.generate(n, (index) => []);
+
+  int calculateBucketIndex(double value, double minVal, double maxVal, int n) {
+    if (value.isNaN || value.isInfinite) {
+      return 0;
+    }
+    if (maxVal == minVal) {
+      return 0;
+    }
+    return ((value - minVal) / (maxVal - minVal) * (n - 1)).floor();
+  }
+
+  for (int i = 0; i < n; i++) {
+    int bucketIndex = calculateBucketIndex(arr[i], minVal, maxVal, n);
+    buckets[bucketIndex].add(arr[i]);
+  }
+
+  int index = 0;
+  for (int i = 0; i < n; i++) {
+    if (buckets[i].isNotEmpty) {
+      buckets[i].sort();
+      for (int j = 0; j < buckets[i].length; j++) {
+        arr[index++] = buckets[i][j];
+      }
+    }
+  }
+}

tests/sort/bucket_sort_test.dart

@@ -0,0 +1,46 @@
+import 'package:test/test.dart';
+import '../../sort/bucket_sort.dart';
+
+void main() {
+  test('Test case 1', () {
+    List<double> arr = [0.42, 0.32, 0.33, 0.52, 0.37, 0.47, 0.51];
+    bucketSort(arr);
+    expect(arr, orderedEquals([0.32, 0.33, 0.37, 0.42, 0.47, 0.51, 0.52]));
+  });
+
+  test('Test case 2', () {
+    List<double> arr = [5.0, 4.0, 3.0, 2.0, 1.0];
+    bucketSort(arr);
+    expect(arr, orderedEquals([1.0, 2.0, 3.0, 4.0, 5.0]));
+  });
+
+  test('Test case 3', () {
+    List<double> arr = [1.1, 2.2, 3.3, 4.4, 5.5];
+    bucketSort(arr);
+    expect(arr, orderedEquals([1.1, 2.2, 3.3, 4.4, 5.5]));
+  });
+
+  test('Test case 4 (Empty List)', () {
+    List<double> arr = [];
+    bucketSort(arr);
+    expect(arr, orderedEquals([]));
+  });
+
+  test('Test case 5 (Already Sorted)', () {
+    List<double> arr = [1.0, 2.0, 3.0, 4.0, 5.0];
+    bucketSort(arr);
+    expect(arr, orderedEquals([1.0, 2.0, 3.0, 4.0, 5.0]));
+  });
+
+  test('Test case 6 (Reverse Sorted)', () {
+    List<double> arr = [5.0, 4.0, 3.0, 2.0, 1.0];
+    bucketSort(arr);
+    expect(arr, orderedEquals([1.0, 2.0, 3.0, 4.0, 5.0]));
+  });
+
+  test('Test case 7 (All Equal)', () {
+    List<double> arr = [2.0, 2.0, 2.0, 2.0, 2.0];
+    bucketSort(arr);
+    expect(arr, orderedEquals([2.0, 2.0, 2.0, 2.0, 2.0]));
+  });
+}