Update to benchmarking

Author: johannes67890

benches/sort_benchmark.rs

@@ -1,26 +1,52 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, BatchSize};
+use rand::{distributions::Uniform, Rng};
 use sorting_algorithm::bubblesort;
 use sorting_algorithm::mergesort;
 use sorting_algorithm::quicksort;
 use sorting_algorithm::insertionsort;
-use sorting_algorithm::generate_random_array;
 
-fn sort_arrays_benchmark(c: &mut Criterion) {
-    let mut arr = black_box([-2,-7 ,2 ,10 ,20 ,9]);
+fn sorting_benchmarks(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Sorting Algorithms");
 
-    c.bench_function("Bubble Sort", |b| b.iter(|| bubblesort(&mut arr)));
-    c.bench_function("Merge Sort", |b| b.iter(|| mergesort(&mut arr)));
-    c.bench_function("Insertion Sort", |b| b.iter(|| insertionsort(&mut arr)));
-    c.bench_function("Quick Sort", |b| b.iter(|| quicksort(&mut arr)));
-}
+    for i in [1,5,10, 25,50,75, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000] { // size of array
+        let mut rng = rand::thread_rng();
+        let range = Uniform::new(0, 100); // range of random numbers
 
-fn sort_random_arrays_benchmark(c: &mut Criterion){
-    let mut random_arr = black_box(generate_random_array(0..100, 10000));
-    c.bench_function("Bubble Sort - Random array", |b| b.iter(|| bubblesort(&mut random_arr)));
-    c.bench_function("Merge Sort - Random array", |b| b.iter(|| mergesort(&mut random_arr)));
-    c.bench_function("Insertion Sort - Random array", |b| b.iter(|| insertionsort(&mut random_arr)));
-    c.bench_function("Quick Sort - Random array", |b| b.iter(|| quicksort(&mut random_arr)));
+        // Bubble sort benchmark (Time complexity: O(n^2))
+        group.bench_function(BenchmarkId::new("Bubble Sort", i), |b| {
+            b.iter_batched_ref(
+                || -> Vec<usize> { (0..i).map(|_| rng.sample(&range)).collect() },
+                |v| bubblesort( v),
+                BatchSize::SmallInput,
+            )
+        });
+        // Merge sort benchmark (Time complexity: O(nlogn))
+        group.bench_function(BenchmarkId::new("Merge Sort", i), |b| {
+            b.iter_batched_ref(
+                || -> Vec<usize> { (0..i).map(|_| rng.sample(&range)).collect() },
+                |v| mergesort (v),
+                BatchSize::SmallInput,
+            )
+        });
+        // Insertion sort benchmark (Time complexity: O(n^2))
+        group.bench_function(BenchmarkId::new("Insertion Sort", i), |b| {
+            b.iter_batched_ref(
+                || -> Vec<usize> { (0..i).map(|_| rng.sample(&range)).collect() },
+                |v| insertionsort (v),
+                BatchSize::SmallInput,
+            )
+        });
+        // Quick sort benchmark (Time complexity: O(nlogn))
+        group.bench_function(BenchmarkId::new("Quick Sort", i), |b| {
+            b.iter_batched_ref(
+                || -> Vec<usize> { (0..i).map(|_| rng.sample(&range)).collect() },
+                |v| quicksort (v),
+                BatchSize::SmallInput,
+            )
+        });
+    }
+    group.finish();
 }
 
-criterion_group!(benches, sort_arrays_benchmark, sort_random_arrays_benchmark);
+criterion_group!(benches, sorting_benchmarks);
 criterion_main!(benches);