Upgrade to NNBD sort algorithms

Author: mafinar-cmb

lib/sorts/common.dart

@@ -1,4 +1,5 @@
-// @dart=2.9
+import '../heaps/base.dart';
+
 /// Comparator function compared [left] with [right]
 typedef Comparator<T extends Comparable> = bool Function(T left, T right);
 
@@ -54,7 +55,7 @@ bool isReverseSorted<T extends Comparable>(List<T> list,
 /// The minimum and maximum values are stored as "min"
 /// and "max" kets in the [Map] returned.
 Map<String, num> findMinMax(List<num> list) {
-  if (list.isEmpty) return null;
+  if (list.isEmpty) throw InvalidIndexError();
 
   var min = list[0];
   var max = list[0];

lib/sorts/distribution.dart

@@ -1,4 +1,3 @@
-// @dart=2.9
 import 'common.dart';
 import 'insertion.dart';
 
@@ -29,8 +28,9 @@ List<int> _countingSort(List<int> list) {
   if (list.isEmpty) return list;
 
   var boundaries = findMinMax(list);
-  var bucket = List<int>.filled(boundaries['max'] + 1, 0);
-  var sorted = List<int>(list.length);
+  var max = boundaries['max'] as int;
+  var bucket = List<int>.filled(max + 1, 0);
+  var sorted = List<int>.filled(list.length, 0);
 
   for (var item in list) {
     bucket[item]++;
@@ -56,7 +56,7 @@ List<int> countingSort(List<int> list, {bool desc = false}) {
 
 void _inPlaceCountSort(List<int> list, int exp) {
   var n = list.length;
-  var sorted = List<int>(n);
+  var sorted = List<int>.filled(n, 0);
   var count = List<int>.filled(10, 0);
 
   for (var i = 0; i < n; i++) {
@@ -81,8 +81,9 @@ List<int> _radixSort(List<int> list) {
   if (list.isEmpty) return list;
 
   var boundaries = findMinMax(list);
+  var max = boundaries['max'] as int;
 
-  for (var exp = 1; boundaries['max'] ~/ exp > 0; exp *= 10) {
+  for (var exp = 1; max ~/ exp > 0; exp *= 10) {
     _inPlaceCountSort(list, exp);
   }
 
@@ -100,11 +101,12 @@ List<int> pigeonholeSort(List<int> list, {bool desc = false}) {
   if (list.isEmpty) return list;
 
   var boundaries = findMinMax(list);
-  var min = boundaries['min'];
-  var size = (boundaries['max'] - boundaries['min']) + 1;
+  var max = boundaries['max'] as int;
+  var min = boundaries['min'] as int;
+  var size = (max - min) + 1;
 
   var pigeonHole = List<int>.filled(size, 0);
-  var sorted = List<int>(list.length);
+  var sorted = List<int>.filled(list.length, 0);
 
   for (var item in list) {
     pigeonHole[item - min]++;
@@ -127,14 +129,16 @@ List<T> bucketSort<T extends num>(List<T> list, {bool desc = false}) {
   if (list.isEmpty) return list;
 
   var boundaries = findMinMax(list);
+  var max = boundaries['max'] as num;
+  var min = boundaries['min'] as num;
 
-  if (boundaries['min'] < 0) {
+  if (min < 0) {
     throw FormatException('This version only takes positive numbers');
   }
 
   var inputLength = list.length;
-  var bucketSize = (boundaries['max'] * inputLength).ceil() + 1;
-  var buckets = List<List<T>>(bucketSize);
+  var bucketSize = (max * inputLength).ceil() + 1;
+  var buckets = List<List<T>>.filled(bucketSize, []);
   for (var i = 0; i < buckets.length; i++) {
     buckets[i] = <T>[];
   }
@@ -144,6 +148,7 @@ List<T> bucketSort<T extends num>(List<T> list, {bool desc = false}) {
     buckets[idx].add(list[i]);
   }
 
-  var sorted = buckets.fold(<T>[], (acc, el) => acc + insertionSort(el));
+  var sorted = buckets.fold(<T>[],
+          (List<T> acc, el) => acc + insertionSort(el));
   return desc ? sorted.reversed.toList() : sorted;
 }

test/sorts/common_test.dart

@@ -1,37 +1,37 @@
-// @dart=2.9
+import 'package:algorithms/heaps/base.dart';
 import 'package:test/test.dart';
 
 import 'package:algorithms/sorts/common.dart';
 
 void main() {
-  List<num> anyList, singleValuedList, emptyList;
+  List<num>? anyList, singleValuedList, emptyList;
   setUp(() {
     emptyList = [];
     singleValuedList = [42];
     anyList = [32, 23, -161, 43, 65, -2, 45, 233, -12];
   });
 
   test('Is unsorted', () {
-    expect(isSorted(anyList), equals(false));
+    expect(isSorted(anyList!), equals(false));
   });
 
   test('Is sorted', () {
-    anyList.sort();
-    expect(isSorted(anyList), equals(true));
-    expect(isSorted(emptyList), equals(true));
-    expect(isSorted(singleValuedList), equals(true));
+    anyList!.sort();
+    expect(isSorted(anyList!), equals(true));
+    expect(isSorted(emptyList!), equals(true));
+    expect(isSorted(singleValuedList!), equals(true));
   });
 
   test('Is reverse sorted', () {
-    anyList.sort();
-    expect(isReverseSorted(anyList.reversed.toList()), equals(true));
-    expect(isReverseSorted(emptyList), equals(true));
-    expect(isReverseSorted(singleValuedList), equals(true));
+    anyList!.sort();
+    expect(isReverseSorted(anyList!.reversed.toList()), equals(true));
+    expect(isReverseSorted(emptyList!), equals(true));
+    expect(isReverseSorted(singleValuedList!), equals(true));
   });
 
   test('Find min and max', () {
-    expect(findMinMax(anyList), equals({'min': -161, 'max': 233}));
-    expect(findMinMax(emptyList), equals(null));
-    expect(findMinMax(singleValuedList), equals({'min': 42, 'max': 42}));
+    expect(findMinMax(anyList!), equals({'min': -161, 'max': 233}));
+    expect(() => findMinMax(emptyList!), throwsA(isA<InvalidIndexError>()));
+    expect(findMinMax(singleValuedList!), equals({'min': 42, 'max': 42}));
   });
 }

test/sorts/distribution_test.dart

@@ -1,24 +1,13 @@
-// @dart=2.9
 import 'package:test/test.dart';
 
 import 'package:algorithms/sorts/distribution.dart';
 
 void main() {
-  List<int> randomList;
-  List<int> positiveRandomList;
-  List<int> sortedRandomListAscending;
-  List<int> sortedRandomListDescending;
-  List<int> sortedPositiveRandomListAscending;
-  List<int> sortedPositiveRandomListDescending;
-  List<int> allNegatives;
-  List<int> someNegatives;
-  List<int> sortedAllNegatives;
-  List<int> sortedSomeNegatives;
-  List<num> randomDistribution;
-  List<num> randomDistributionSorted;
-
-  List<int> emptyList;
-
+  List<int>? randomList, positiveRandomList, sortedRandomListAscending,
+      sortedRandomListDescending, sortedPositiveRandomListAscending,
+      sortedPositiveRandomListDescending, allNegatives, someNegatives,
+      sortedAllNegatives, sortedSomeNegatives, emptyList;
+  List<double>? randomDistribution, randomDistributionSorted;
   setUp(() {
     emptyList = [];
     randomList = [2, 4, 2, 1, -1, 0, 20];
@@ -39,67 +28,67 @@ void main() {
   });
 
   test('Pigeonhole Sort', () {
-    expect(pigeonholeSort(randomList), equals(sortedRandomListAscending));
-    expect(pigeonholeSort(randomList, desc: false),
+    expect(pigeonholeSort(randomList!), equals(sortedRandomListAscending));
+    expect(pigeonholeSort(randomList!, desc: false),
         equals(sortedRandomListAscending));
-    expect(pigeonholeSort(randomList, desc: true),
+    expect(pigeonholeSort(randomList!, desc: true),
         equals(sortedRandomListDescending));
 
-    expect(pigeonholeSort(emptyList), equals(emptyList));
-    expect(pigeonholeSort(emptyList, desc: false), equals(emptyList));
-    expect(pigeonholeSort(emptyList, desc: true), equals(emptyList));
+    expect(pigeonholeSort(emptyList!), equals(emptyList));
+    expect(pigeonholeSort(emptyList!, desc: false), equals(emptyList));
+    expect(pigeonholeSort(emptyList!, desc: true), equals(emptyList));
   });
 
   test('Counting Sort', () {
-    expect(countingSort(positiveRandomList),
+    expect(countingSort(positiveRandomList!),
         equals(sortedPositiveRandomListAscending));
-    expect(countingSort(positiveRandomList, desc: false),
+    expect(countingSort(positiveRandomList!, desc: false),
         equals(sortedPositiveRandomListAscending));
-    expect(countingSort(positiveRandomList, desc: true),
+    expect(countingSort(positiveRandomList!, desc: true),
         equals(sortedPositiveRandomListDescending));
 
-    expect(countingSort(emptyList), equals(emptyList));
-    expect(countingSort(emptyList, desc: false), equals(emptyList));
-    expect(countingSort(emptyList, desc: true), equals(emptyList));
+    expect(countingSort(emptyList!), equals(emptyList));
+    expect(countingSort(emptyList!, desc: false), equals(emptyList));
+    expect(countingSort(emptyList!, desc: true), equals(emptyList));
 
-    expect(countingSort(allNegatives), equals(sortedAllNegatives));
-    expect(countingSort(someNegatives), equals(sortedSomeNegatives));
+    expect(countingSort(allNegatives!), equals(sortedAllNegatives));
+    expect(countingSort(someNegatives!), equals(sortedSomeNegatives));
   });
 
   test('Radix Sort for positive numbers', () {
-    expect(radixSort(positiveRandomList),
+    expect(radixSort(positiveRandomList!),
         equals(sortedPositiveRandomListAscending));
-    expect(radixSort(positiveRandomList, desc: false),
+    expect(radixSort(positiveRandomList!, desc: false),
         equals(sortedPositiveRandomListAscending));
-    expect(radixSort(positiveRandomList, desc: true),
+    expect(radixSort(positiveRandomList!, desc: true),
         equals(sortedPositiveRandomListDescending));
 
-    expect(radixSort(emptyList), equals(emptyList));
-    expect(radixSort(emptyList, desc: false), equals(emptyList));
-    expect(radixSort(emptyList, desc: true), equals(emptyList));
+    expect(radixSort(emptyList!), equals(emptyList));
+    expect(radixSort(emptyList!, desc: false), equals(emptyList));
+    expect(radixSort(emptyList!, desc: true), equals(emptyList));
 
-    expect(radixSort(allNegatives), equals(sortedAllNegatives));
-    expect(radixSort(someNegatives), equals(sortedSomeNegatives));
+    expect(radixSort(allNegatives!), equals(sortedAllNegatives));
+    expect(radixSort(someNegatives!), equals(sortedSomeNegatives));
   });
 
   test('Bucket sort for positive numbers', () {
-    expect(bucketSort(positiveRandomList),
+    expect(bucketSort(positiveRandomList!),
         equals(sortedPositiveRandomListAscending));
-    expect(bucketSort(positiveRandomList, desc: false),
+    expect(bucketSort(positiveRandomList!, desc: false),
         equals(sortedPositiveRandomListAscending));
-    expect(bucketSort(positiveRandomList, desc: true),
+    expect(bucketSort(positiveRandomList!, desc: true),
         equals(sortedPositiveRandomListDescending));
-    expect(bucketSort(randomDistribution), equals(randomDistributionSorted));
-    expect(bucketSort(randomDistribution, desc: true),
-        equals(randomDistributionSorted.reversed));
+    expect(bucketSort(randomDistribution!), equals(randomDistributionSorted));
+    expect(bucketSort(randomDistribution!, desc: true),
+        equals(randomDistributionSorted!.reversed));
 
-    expect(bucketSort(emptyList), equals(emptyList));
-    expect(bucketSort(emptyList, desc: false), equals(emptyList));
-    expect(bucketSort(emptyList, desc: true), equals(emptyList));
+    expect(bucketSort(emptyList!), equals(emptyList));
+    expect(bucketSort(emptyList!, desc: false), equals(emptyList));
+    expect(bucketSort(emptyList!, desc: true), equals(emptyList));
   });
 
   test('Bucket sort for negative numbers', () {
-    expect(() => bucketSort(allNegatives), throwsA(isA<FormatException>()));
-    expect(() => bucketSort(someNegatives), throwsA(isA<FormatException>()));
+    expect(() => bucketSort(allNegatives!), throwsA(isA<FormatException>()));
+    expect(() => bucketSort(someNegatives!), throwsA(isA<FormatException>()));
   });
 }

test/sorts/exchange_test.dart

@@ -1,14 +1,11 @@
-// @dart=2.9
 import 'package:test/test.dart';
 
 import 'package:algorithms/sorts/exchange.dart';
 
 void main() {
-  List<int> randomList;
-  List<int> sortedRandomListAscending;
-  List<int> sortedRandomListDescending;
+  List<int>? randomList, sortedRandomListAscending, sortedRandomListDescending;
 
-  List<String> emptyList;
+  List<String>? emptyList;
 
   bool ascendingFn(left, right) => left <= right;
   bool descendingFn(left, right) => left >= right;
@@ -21,50 +18,50 @@ void main() {
   });
 
   test('Bubble Sort', () {
-    expect(bubbleSort(randomList), equals(sortedRandomListAscending));
+    expect(bubbleSort(randomList!), equals(sortedRandomListAscending));
     expect(
-        bubbleSort(randomList, ascendingFn), equals(sortedRandomListAscending));
-    expect(bubbleSort(randomList, descendingFn),
+        bubbleSort(randomList!, ascendingFn), equals(sortedRandomListAscending));
+    expect(bubbleSort(randomList!, descendingFn),
         equals(sortedRandomListDescending));
 
-    expect(bubbleSort(emptyList), equals(emptyList));
-    expect(bubbleSort(emptyList, ascendingFn), equals(emptyList));
-    expect(bubbleSort(emptyList, descendingFn), equals(emptyList));
+    expect(bubbleSort(emptyList!), equals(emptyList));
+    expect(bubbleSort(emptyList!, ascendingFn), equals(emptyList));
+    expect(bubbleSort(emptyList!, descendingFn), equals(emptyList));
   });
 
   test('Odd-Event Sort', () {
-    expect(oddEvenSort(randomList), equals(sortedRandomListAscending));
-    expect(oddEvenSort(randomList, ascendingFn),
+    expect(oddEvenSort(randomList!), equals(sortedRandomListAscending));
+    expect(oddEvenSort(randomList!, ascendingFn),
         equals(sortedRandomListAscending));
-    expect(oddEvenSort(randomList, descendingFn),
+    expect(oddEvenSort(randomList!, descendingFn),
         equals(sortedRandomListDescending));
 
-    expect(oddEvenSort(emptyList), equals(emptyList));
-    expect(oddEvenSort(emptyList, ascendingFn), equals(emptyList));
-    expect(oddEvenSort(emptyList, descendingFn), equals(emptyList));
+    expect(oddEvenSort(emptyList!), equals(emptyList));
+    expect(oddEvenSort(emptyList!, ascendingFn), equals(emptyList));
+    expect(oddEvenSort(emptyList!, descendingFn), equals(emptyList));
   });
 
   test('Gnome Sort', () {
-    expect(gnomeSort(randomList), equals(sortedRandomListAscending));
+    expect(gnomeSort(randomList!), equals(sortedRandomListAscending));
     expect(
-        gnomeSort(randomList, ascendingFn), equals(sortedRandomListAscending));
-    expect(gnomeSort(randomList, descendingFn),
+        gnomeSort(randomList!, ascendingFn), equals(sortedRandomListAscending));
+    expect(gnomeSort(randomList!, descendingFn),
         equals(sortedRandomListDescending));
 
-    expect(gnomeSort(emptyList), equals(emptyList));
-    expect(gnomeSort(emptyList, ascendingFn), equals(emptyList));
-    expect(gnomeSort(emptyList, descendingFn), equals(emptyList));
+    expect(gnomeSort(emptyList!), equals(emptyList));
+    expect(gnomeSort(emptyList!, ascendingFn), equals(emptyList));
+    expect(gnomeSort(emptyList!, descendingFn), equals(emptyList));
   });
 
   test('Quick Sort', () {
-    expect(quickSort(randomList), equals(sortedRandomListAscending));
+    expect(quickSort(randomList!), equals(sortedRandomListAscending));
     expect(
-        quickSort(randomList, ascendingFn), equals(sortedRandomListAscending));
-    expect(quickSort(randomList, descendingFn),
+        quickSort(randomList!, ascendingFn), equals(sortedRandomListAscending));
+    expect(quickSort(randomList!, descendingFn),
         equals(sortedRandomListDescending));
 
-    expect(quickSort(emptyList), equals(emptyList));
-    expect(quickSort(emptyList, ascendingFn), equals(emptyList));
-    expect(quickSort(emptyList, descendingFn), equals(emptyList));
+    expect(quickSort(emptyList!), equals(emptyList));
+    expect(quickSort(emptyList!, ascendingFn), equals(emptyList));
+    expect(quickSort(emptyList!, descendingFn), equals(emptyList));
   });
 }