misc.rs -> order.rs, with mergesort

Author: EbTech

README.md

@@ -45,12 +45,13 @@ Rather than try to persuade you with words, this repository aims to show by exam
 
 - [Basic graph representations](src/graph/mod.rs): adjacency lists, disjoint set union
 - [Elementary graph algorithms](src/graph/util.rs): minimum spanning tree, Euler path, Dijkstra's algorithm, DFS iteration
-- [Network flows](src/graph/flow.rs): Dinic's blocking flow, Hopcroft-Karp bipartite matching, min cost max flow
 - [Connected components](src/graph/connectivity.rs): 2-edge-, 2-vertex- and strongly connected components, bridges, articulation points, topological sort, 2-SAT
-- [Associative range query](src/range_query): known colloquially as *segtrees*, as well as Mo's query square root decomposition
+- [Network flows](src/graph/flow.rs): Dinic's blocking flow, Hopcroft-Karp bipartite matching, min cost max flow
 - [Number theory](src/math/mod.rs): canonical solution to Bezout's identity, Miller's primality test
-- [Arithmetic](src/math/num.rs): rational and complex numbers, linear algebra, safe modular arithmetic
 - [FFT](src/math/fft.rs): fast Fourier transform, number theoretic transform, convolution
+- [Arithmetic](src/math/num.rs): rational and complex numbers, linear algebra, safe modular arithmetic
+- [Ordering algorithms](src/order.rs): binary search, mergesort, coordinate compression, amortized convex hull trick
+- [Associative range query](src/range_query): static and dynamic ARQ trees (a.k.a. segtrees), Mo's query square root decomposition
 - [Scanner](src/scanner.rs): utility for reading input data ergonomically
 - [String processing](src/string_proc.rs): Knuth-Morris-Pratt and Aho-Corasick string matching, suffix array, Manacher's linear-time palindrome search
-- [Miscellaneous algorithms](src/misc.rs): slice binary search, coordinate compression, convex hull trick with sqrt decomposition
+

src/graph/mod.rs

@@ -5,7 +5,7 @@
 //! All methods will panic if given an out-of-bounds element index.
 pub mod connectivity;
 pub mod flow;
-mod util;
+pub mod util;
 
 /// Represents a union of disjoint sets. Each set's elements are arranged in a
 /// tree, whose root is the set's representative.

src/lib.rs

@@ -1,7 +1,7 @@
 //! Algorithms Cookbook in Rust.
 pub mod graph;
 pub mod math;
-pub mod misc;
+pub mod order;
 pub mod range_query;
 pub mod scanner;
 pub mod string_proc;

src/misc.rs renamed to src/order.rs

@@ -5,23 +5,23 @@ pub fn asserting_cmp<T: PartialOrd>(a: &T, b: &T) -> std::cmp::Ordering {
     a.partial_cmp(b).expect("Comparing incomparable elements")
 }
 
-/// Assuming slice is totally ordered and sorted, returns the minimum i for which
+/// Assuming slice is sorted and totally ordered, returns the minimum i for which
 /// slice[i] >= key, or slice.len() if no such i exists
 pub fn slice_lower_bound<T: PartialOrd>(slice: &[T], key: &T) -> usize {
     slice
         .binary_search_by(|x| asserting_cmp(x, key).then(std::cmp::Ordering::Greater))
         .unwrap_err()
 }
 
-/// Assuming slice is totally ordered and sorted, returns the minimum i for which
+/// Assuming slice is sorted and totally ordered, returns the minimum i for which
 /// slice[i] > key, or slice.len() if no such i exists
 pub fn slice_upper_bound<T: PartialOrd>(slice: &[T], key: &T) -> usize {
     slice
         .binary_search_by(|x| asserting_cmp(x, key).then(std::cmp::Ordering::Less))
         .unwrap_err()
 }
 
-/// Merge two sorted collections into one
+/// Merge two sorted and totally ordered collections into one
 pub fn merge_sorted<T: PartialOrd>(
     i1: impl IntoIterator<Item = T>,
     i2: impl IntoIterator<Item = T>,
@@ -35,6 +35,16 @@ pub fn merge_sorted<T: PartialOrd>(
     merged
 }
 
+/// A stable sort
+pub fn merge_sort<T: Ord>(mut v: Vec<T>) -> Vec<T> {
+    if v.len() < 2 {
+        v
+    } else {
+        let v2 = v.split_off(v.len() / 2);
+        merge_sorted(merge_sort(v), merge_sort(v2))
+    }
+}
+
 /// A simple data structure for coordinate compression
 pub struct SparseIndex {
     coords: Vec<i64>,
@@ -58,9 +68,9 @@ impl SparseIndex {
 /// Represents a maximum (upper envelope) of a collection of linear functions of a variable,
 /// evaluated using the convex hull trick with square root decomposition.
 pub struct PiecewiseLinearFn {
+    recent_lines: Vec<(f64, f64)>,
     sorted_lines: Vec<(f64, f64)>,
     intersections: Vec<f64>,
-    recent_lines: Vec<(f64, f64)>,
     merge_threshold: usize,
 }
 
@@ -70,9 +80,9 @@ impl PiecewiseLinearFn {
     /// any threshold less than N (e.g., 0) yields O(N + Q log N) time complexity.
     pub fn with_merge_threshold(merge_threshold: usize) -> Self {
         Self {
+            recent_lines: vec![],
             sorted_lines: vec![],
             intersections: vec![],
-            recent_lines: vec![],
             merge_threshold,
         }
     }
@@ -155,6 +165,15 @@ mod test {
         assert_eq!(merge_sorted(vals1, vals2), vals_merged);
     }
 
+    #[test]
+    fn test_merge_sort() {
+        let unsorted = vec![8, -5, 1, 4, -3, 4];
+        let sorted = vec![-5, -3, 1, 4, 4, 8];
+
+        assert_eq!(merge_sort(unsorted), sorted);
+        assert_eq!(merge_sort(sorted.clone()), sorted);
+    }
+
     #[test]
     fn test_coord_compress() {
         let mut coords = vec![16, 99, 45, 18];