feat: Add performance benchmarks for various modules and expose funda…

Cargo.toml

@@ -18,6 +18,7 @@ license = "GPL-3.0"
 repository = "https://github.com/tekawade/algs4-rust"
 keywords = ["algorithms", "data-structures", "education"]
 categories = ["algorithms", "data-structures"]
+rust-version = "1.82.0"
 
 [workspace.dependencies]
 # Common dependencies shared across modules

README.md

@@ -517,20 +517,29 @@ cargo test --doc
 ```
 
 ### Benchmarking
-
-```bash
-# Run graph benchmarks
-cargo bench -p algs4-graphs
-
-# Benchmarks include:
-# - Graph creation
-# - DFS/BFS traversal
-# - Connected components
-# - Dijkstra shortest paths
-# - Minimum spanning trees
-# - Topological sort
-# - Strongly connected components
-```
+
+ ```bash
+ # Run benchmarks for specific module
+ cargo bench -p algs4-fundamentals
+ cargo bench -p algs4-sorting
+ cargo bench -p algs4-searching
+ cargo bench -p algs4-graphs
+ cargo bench -p algs4-strings
+ cargo bench -p algs4-geometry
+ cargo bench -p algs4-advanced
+
+ # Run all benchmarks (may take a while)
+ cargo bench --workspace
+
+ # Benchmarks include:
+ # - Fundamentals: Bags, Queues, Stacks, Union-Find
+ # - Sorting: All major sorting algorithms (Elementary, Merge, Quick, Heap, String Sorts)
+ # - Searching: BST, Red-Black BST, Hash Tables, Tries
+ # - Graphs: Traversal, Shortest Paths, MST, etc.
+ # - Strings: Pattern Matching (KMP), Tries
+ # - Geometry: Convex Hull
+ # - Advanced: Fenwick Tree, B-Tree
+ ```
 
 ### Documentation
 

modules/advanced/Cargo.toml

@@ -15,3 +15,9 @@ algs4-searching = { version = "0.1.0", path = "../searching" }
 algs4-graphs = { version = "0.1.0", path = "../graphs" }
 
 [dev-dependencies]
+criterion = "0.5"
+rand = "0.8"
+
+[[bench]]
+name = "advanced_benchmarks"
+harness = false

modules/advanced/benches/advanced_benchmarks.rs

@@ -0,0 +1,30 @@
+use algs4_advanced::fenwick_tree::FenwickTree;
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use rand::prelude::SliceRandom;
+use rand::thread_rng;
+
+fn advanced_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("advanced");
+
+    for size in [1000, 5000].iter() {
+        let mut rng = thread_rng();
+        let mut data: Vec<i32> = (0..*size as i32).collect();
+        data.shuffle(&mut rng);
+
+        group.bench_with_input(
+            BenchmarkId::new("fenwick_tree_sum", size),
+            size,
+            |b, &size| {
+                b.iter(|| {
+                    let data = vec![1; size];
+                    let ft = FenwickTree::new(black_box(data));
+                    ft.rsq(size - 1)
+                });
+            },
+        );
+    }
+    group.finish();
+}
+
+criterion_group!(benches, advanced_benchmark);
+criterion_main!(benches);

modules/fundamentals/Cargo.toml

@@ -16,3 +16,9 @@ lazy_static = "1.5"
 byteorder = { workspace = true }
 
 [dev-dependencies]
+criterion = "0.5"
+rand = "0.8"
+
+[[bench]]
+name = "fundamentals_benchmarks"
+harness = false

modules/fundamentals/benches/fundamentals_benchmarks.rs

@@ -0,0 +1,174 @@
+use algs4_fundamentals::collections::linked_bag::LinkedBag;
+use algs4_fundamentals::collections::linked_queue::LinkedQueue;
+use algs4_fundamentals::collections::linked_stack::LinkedStack;
+use algs4_fundamentals::collections::resizing_array_bag::ResizingArrayBag;
+use algs4_fundamentals::collections::resizing_array_queue::ResizingArrayQueue;
+use algs4_fundamentals::collections::resizing_array_stack::ResizingArrayStack;
+use algs4_fundamentals::union_find::quick_find_uf::QuickFindUF;
+use algs4_fundamentals::union_find::quick_union_uf::QuickUnionUF;
+use algs4_fundamentals::union_find::weighted_quick_union_uf::WeightedQuickUnionUF;
+use algs4_fundamentals::union_find::weighted_quick_union_uf::WeightedQuickUnionUF as UF; // UF trait might not be public or exist as named
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+
+fn bag_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("bag");
+
+    for size in [1000, 10000].iter() {
+        group.bench_with_input(
+            BenchmarkId::new("linked_bag_add", size),
+            size,
+            |b, &size| {
+                b.iter(|| {
+                    let mut bag = LinkedBag::new();
+                    for i in 0..size {
+                        bag.add(black_box(i));
+                    }
+                });
+            },
+        );
+
+        group.bench_with_input(
+            BenchmarkId::new("resizing_array_bag_add", size),
+            size,
+            |b, &size| {
+                b.iter(|| {
+                    let mut bag = ResizingArrayBag::new();
+                    for i in 0..size {
+                        bag.add(black_box(i));
+                    }
+                });
+            },
+        );
+    }
+    group.finish();
+}
+
+fn queue_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("queue");
+
+    for size in [1000, 10000].iter() {
+        group.bench_with_input(
+            BenchmarkId::new("linked_queue_enqueue_dequeue", size),
+            size,
+            |b, &size| {
+                b.iter(|| {
+                    let mut queue = LinkedQueue::new();
+                    for i in 0..size {
+                        queue.enqueue(black_box(i));
+                    }
+                    for _ in 0..size {
+                        queue.dequeue();
+                    }
+                });
+            },
+        );
+
+        group.bench_with_input(
+            BenchmarkId::new("resizing_array_queue_enqueue_dequeue", size),
+            size,
+            |b, &size| {
+                b.iter(|| {
+                    let mut queue = ResizingArrayQueue::new();
+                    for i in 0..size {
+                        queue.enqueue(black_box(i));
+                    }
+                    for _ in 0..size {
+                        queue.dequeue();
+                    }
+                });
+            },
+        );
+    }
+    group.finish();
+}
+
+fn stack_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("stack");
+
+    for size in [1000, 10000].iter() {
+        group.bench_with_input(
+            BenchmarkId::new("linked_stack_push_pop", size),
+            size,
+            |b, &size| {
+                b.iter(|| {
+                    let mut stack = LinkedStack::new();
+                    for i in 0..size {
+                        stack.push(black_box(i));
+                    }
+                    for _ in 0..size {
+                        stack.pop();
+                    }
+                });
+            },
+        );
+
+        group.bench_with_input(
+            BenchmarkId::new("resizing_array_stack_push_pop", size),
+            size,
+            |b, &size| {
+                b.iter(|| {
+                    let mut stack = ResizingArrayStack::new();
+                    for i in 0..size {
+                        stack.push(black_box(i));
+                    }
+                    for _ in 0..size {
+                        stack.pop();
+                    }
+                });
+            },
+        );
+    }
+    group.finish();
+}
+
+fn union_find_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("union_find");
+
+    for size in [1000, 5000].iter() {
+        let ops = size * 2;
+
+        group.bench_with_input(BenchmarkId::new("quick_find", size), size, |b, &size| {
+            b.iter(|| {
+                let mut uf = QuickFindUF::new(black_box(size));
+                for i in 0..size - 1 {
+                    uf.union(i, i + 1);
+                }
+                uf.connected(0, size - 1)
+            });
+        });
+
+        group.bench_with_input(BenchmarkId::new("quick_union", size), size, |b, &size| {
+            b.iter(|| {
+                let mut uf = QuickUnionUF::new(black_box(size));
+                for i in 0..size - 1 {
+                    uf.union(i, i + 1);
+                }
+                uf.connected(0, size - 1)
+            });
+        });
+
+        group.bench_with_input(
+            BenchmarkId::new("weighted_quick_union", size),
+            size,
+            |b, &size| {
+                b.iter(|| {
+                    let mut uf = WeightedQuickUnionUF::new(black_box(size));
+                    for i in 0..size - 1 {
+                        uf.union(i, i + 1);
+                    }
+                    uf.connected(0, size - 1)
+                });
+            },
+        );
+    }
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bag_benchmark,
+    queue_benchmark,
+    stack_benchmark,
+    union_find_benchmark
+);
+criterion_main!(benches);

modules/fundamentals/src/collections/mod.rs

@@ -12,18 +12,18 @@
 //! **Reference:** <https://algs4.cs.princeton.edu/13stacks>
 
 // Linked implementations
-mod linked_bag;
-mod linked_queue;
-mod linked_stack;
+pub mod linked_bag;
+pub mod linked_queue;
+pub mod linked_stack;
 
 pub use linked_bag::LinkedBag;
 pub use linked_queue::LinkedQueue;
 pub use linked_stack::LinkedStack;
 
 // Array implementations
-mod resizing_array_bag;
-mod resizing_array_queue;
-mod resizing_array_stack;
+pub mod resizing_array_bag;
+pub mod resizing_array_queue;
+pub mod resizing_array_stack;
 
 pub use resizing_array_bag::ResizingArrayBag;
 pub use resizing_array_queue::ResizingArrayQueue;

modules/fundamentals/src/union_find/mod.rs

@@ -39,9 +39,9 @@
 //!
 //! **Reference:** <https://algs4.cs.princeton.edu/15uf>
 
-mod quick_find_uf;
-mod quick_union_uf;
-mod weighted_quick_union_uf;
+pub mod quick_find_uf;
+pub mod quick_union_uf;
+pub mod weighted_quick_union_uf;
 
 pub use quick_find_uf::QuickFindUF;
 pub use quick_union_uf::QuickUnionUF;

modules/geometry/Cargo.toml

@@ -13,3 +13,9 @@ description = "Geometric algorithms from Algorithms 4th Edition"
 algs4-fundamentals = { version = "0.1.0", path = "../fundamentals" }
 
 [dev-dependencies]
+criterion = "0.5"
+rand = "0.8"
+
+[[bench]]
+name = "geometry_benchmarks"
+harness = false

modules/geometry/benches/geometry_benchmarks.rs

@@ -0,0 +1,26 @@
+use algs4_geometry::graham_scan::GrahamScan;
+use algs4_geometry::point2d::Point2D;
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use rand::{thread_rng, Rng};
+
+fn geometry_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("geometry");
+
+    for size in [1000, 5000].iter() {
+        let mut rng = thread_rng();
+        let points: Vec<Point2D> = (0..*size)
+            .map(|_| Point2D::new(rng.gen_range(0.0..100.0), rng.gen_range(0.0..100.0)))
+            .collect();
+
+        group.bench_with_input(BenchmarkId::new("graham_scan", size), &points, |b, pts| {
+            b.iter(|| {
+                let mut p = pts.clone();
+                GrahamScan::new(black_box(&mut p));
+            });
+        });
+    }
+    group.finish();
+}
+
+criterion_group!(benches, geometry_benchmark);
+criterion_main!(benches);

modules/searching/Cargo.toml

@@ -13,3 +13,9 @@ description = "Searching algorithms and symbol tables from Algorithms 4th Editio
 algs4-fundamentals = { version = "0.1.0", path = "../fundamentals" }
 
 [dev-dependencies]
+criterion = "0.5"
+rand = "0.8"
+
+[[bench]]
+name = "searching_benchmarks"
+harness = false