fix: fixed quicksort to use randomized version and added radix sort

Author: MrUnfunny

lib/sort-algos/quick.dart

@@ -1,3 +1,5 @@
+import 'dart:math';
+
 import '../models/item.dart';
 import '../models/step.dart';
 
@@ -41,12 +43,25 @@ void quickSortAlgo(List<Step> result, int low, int high) {
 }
 
 int partition(List<Step> result, int low, int high) {
-  var pivot = high;
+  var random = Random();
+  var pivot = low + random.nextInt(high - low);
 
   var step = List<Item>.from(result.last.list);
 
   var i = low - 1;
 
+  var temp1 = step[pivot].copyWith(color: matchActiveColor);
+  step[pivot] = step[high].copyWith(color: matchActiveColor);
+  step[high] = temp1;
+
+  result.add(Step(List<Item>.from(step),
+      'Randomly choose ${step[high]} and swapped it with ${step[pivot]}'));
+
+  step[pivot] = step[pivot].copyWith(color: defaultColor);
+  step[high] = step[high].copyWith(color: defaultColor);
+
+  pivot = high;
+
   step[pivot] = step[pivot].copyWith(color: matchActiveColor);
 
   for (var j = low; j < high; j++) {

lib/sort-algos/radix.dart

@@ -0,0 +1,75 @@
+import 'dart:math';
+
+import '../models/item.dart';
+import '../models/step.dart';
+import '../utils.dart';
+
+List<Step> radixSort(List<Item> input) {
+  var result = <Step>[];
+  var largest = max(input);
+
+  var step = Step(<Item>[], 'Starting Position');
+
+  for (var i = 0; i < input.length; i++) {
+    step.list.add(
+      Item(
+        i,
+        input[i].value,
+        defaultColor,
+      ),
+    );
+  }
+
+  result.add(Step(List<Item>.from(step.list), step.reason));
+
+  for (var e = 1; (largest / e).floor() > 0; e *= 10) {
+    countSort(
+        input, result, e, (largest / e).floor() % 10 == (largest / e).floor());
+
+    result.add(Step(List<Item>.from(input),
+        'Sorted according to significant digit no. ${logBase(e, 10) + 1}'));
+  }
+
+  result.add(Step(List<Item>.from(input), 'Sorted'));
+
+  return result;
+}
+
+void countSort(List<Item> a, List<Step> result, int e, bool last) {
+  var cnt = List<int>.filled(10, 0);
+  var res = List<Item>.filled(a.length, Item(0, 0, defaultColor));
+
+  for (var i = 0; i < a.length; ++i) {
+    cnt[(a[i].value / e).floor() % 10]++;
+  }
+
+  for (var i = 1; i < cnt.length; ++i) {
+    cnt[i] += cnt[i - 1];
+  }
+
+  for (var i = a.length - 1; i >= 0; --i) {
+    res[cnt[(a[i].value / e).floor() % 10] - 1] =
+        last ? a[i].copyWith(color: sortedColor) : a[i];
+    result.add(Step(List<Item>.from(res),
+        'put ${res[cnt[(a[i].value / e).floor() % 10] - 1]} in place'));
+
+    cnt[(a[i].value / e).floor() % 10]--;
+  }
+
+  for (var i = 0; i < a.length; i++) {
+    a[i] = res[i];
+  }
+}
+
+int max(List<Item> a) {
+  var largest = -10e9.toInt();
+  for (var i in a) {
+    if (i.value > largest) {
+      largest = i.value;
+    }
+  }
+
+  return largest;
+}
+
+double logBase(num x, num base) => log(x) / log(base);

lib/utils.dart

@@ -8,6 +8,7 @@ import 'sort-algos/heapsort.dart';
 import 'sort-algos/insertion.dart';
 import 'sort-algos/merge.dart';
 import 'sort-algos/quick.dart';
+import 'sort-algos/radix.dart';
 import 'sort-algos/selection.dart';
 
 const matchActiveColor = Color(0xFF8CDAD8);
@@ -63,6 +64,14 @@ final List<Algorithm> sortAlgos = [
     url: 'https://en.wikipedia.org/wiki/Selection_sort',
     function: heapSort,
   ),
+  Algorithm(
+    id: 6,
+    name: 'Radix Sort',
+    algoType: AlgoType.sorting,
+    image: 'assets/thumbnails/heap.gif',
+    url: 'https://en.wikipedia.org/wiki/Selection_sort',
+    function: radixSort,
+  ),
 ];
 
 final defaultSteps = [