Added dual quicksort, edited docs

Author: flakusha

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sorting_rs"
-version = "1.2.3"
+version = "1.2.4"
 authors = ["flakusha <[email protected]>"]
 edition = "2018"
 repository = "https://github.com/flakusha/rust_sorting"

README.md

@@ -3,21 +3,20 @@ Sorting algorithms implemented in Rust
 ## Usage
 1. Add this dependency and please consider it's version into your Cargo.toml:
 ```toml
-...
 [dependencies]
 sorting_rs = "1.2.0"
-...
 ```
 2. Use available sorting algorithms in your Rust code:
 ```rust
 use sorting_rs::*;
-...
 ```
 3. For more information about origin of algorithms and implementation details, 
-please read modules documentation 
+please read modules documentation.
+[wikipedia](https://en.wikipedia.org/wiki/Sorting_algorithm) is nice starting
+point too
+4. For API 
 
 ## This library contains following sorting algorithms:
-New algorithms implementations are planned
 
 | Sorting algorithm | Features and downsides | Worst-case performance O(): comparisons; swaps | Best-case performance O(): comparisons; swaps | Space complexity O() |
 | -------------- | -------------------------------- | -------- | -------- | ------------- |
@@ -27,16 +26,19 @@ New algorithms implementations are planned
 | Gnome | simple and slow, works with one item at a time | `n`<sup>`2`</sup> | `n` | `1` |
 | Heap | independent of data distribution | `nlogn` | `nlogn` or `n` | `n` or `1` |
 | Weak Heap | independent of data distribution, decreased amount of comparisons | `nlogn` | `nlogn` or `n` | `n` or `1` |
-| N-Heap | independent of data distribution | `nlogn` | `nlogn` or `n` | `n` or `1` |
+| N-Heap | independent of data distribution, should be faster than default heap. n = 3 | `nlogn` | `nlogn` or `n` | `n` or `1` |
 | Bottom-up Heap | upgraded version of heapsort with decreased number of comparisons | `nlogn` | `nlogn` or `n` | `n` or `1` |
 | Insertion | simple, but less effective than quicksort, heapsort or merge sort | `n`<sup>`2`</sup>; `n`<sup>`2`</sup> | `n`; `1` | `n` or `1` |
-| Merge | independent of data distribution | `nlogn` | `nlogn` or `n` | `n` |
+| Merge | independent of data distribution | `nlogn` | `nlogn` | `n` |
 | Odd-even | presented to be effective on processors with local interconnections | `n`<sup>`2`</sup> | `n` | `1` |
 | Odd-even (Batcher) | more efficient version of odd-even sort | `log`<sup>`2`</sup>`n` | `log`<sup>`2`</sup>`n` | `log`<sup>`2`</sup>`n` |
 | Quick | bad for sorted or reversed input | `n`<sup>`2`</sup> | `nlog`<sub>2</sub>`n` | `n` or `logn` |
+| Quick dual | enchanced version of quicksort | `n`<sup>`2`</sup> | `2nlnn` | `n` or `logn` |
 | Ksort | modified version of quicksort, faster than heap at less than 7 million elements | `n`<sup>`2`</sup> | `nlog`<sub>2</sub>`n` | `n` or `logn` |
 | Selection | the least number of swaps among all the algorithms | `n`<sup>`2`</sup>; `n` | `n`<sup>`2`</sup>; `1` | `1` |
-| Shell | it is optimization of insertion sort | `n`<sup>`2`</sup> or `nlog`<sup>`2`</sup>`n` | `nlogn` or `nlog`<sup>`2`</sup>`n` | `n` |
+| Shellsort | it is optimization of insertion sort | `n`<sup>`3/2`</sup> or `nlog`<sup>`2`</sup>`n` | `nlogn` | `1` |
 | Slow | it's slow, who would ever need it? | | | |
 | Smooth | variant of heapsort, good for nearly sorted data | `nlogn` | `n` | `n` or `1` |
-| Stooge | it's a bit faster than slow sort | `n`<sup>`2.7095`</sup> | | `n` |
+| Stooge | it's a bit faster than slow sort | `n`<sup>`2.7095`</sup> | | `n` |
+
+New algorithms implementations are planned

benches/sort_benchmark.rs

@@ -48,6 +48,7 @@ fn bench(c: &mut Criterion) {
         nheap_sort,
         oddeven_sort,
         quick_sort,
+        quick_dual_sort,
         selection_sort,
         shell_sort,
         smooth_sort

src/bin/leonardo_numbers.rs

@@ -1,12 +1,12 @@
-/// Additional private binary to print Leonardo and Fibonnaci numbers
-/// Leonardo numbers are then used in smoothsort algorithm
-/// This one can be useful in case you need to modify algorithm to use with
-/// 32-, 64-, 128-bit and other systems
-/// This addition uses usize in case there is mainstream 64-bit system
-/// # Usage:
-/// ```ignore
-/// cargo run leonardo_numbers
-/// ```
+//! Additional private binary to print Leonardo and Fibonnaci numbers.
+//! Leonardo numbers are used in smoothsort algorithm as constant.
+//! This one can be useful in case you need to modify algorithm to use with
+//! 32-, 64-, 128-bit and other systems.
+//! This addition uses usize in case there is mainstream 64-bit system
+//! # Usage:
+//! ```ignore
+//! cargo run leonardo_numbers
+//! ```
 use std::io;
 
 fn leonardo_generate(mut n0: usize, mut n1: usize, add: usize) ->

src/lib.rs

@@ -8,16 +8,17 @@
 //! | Gnome | simple and slow, works with one item at a time | `n`<sup>`2`</sup> | `n` | `1` |
 //! | Heap | independent of data distribution | `nlogn` | `nlogn` or `n` | `n` or `1` |
 //! | Weak Heap | independent of data distribution, decreased amount of comparisons | `nlogn` | `nlogn` or `n` | `n` or `1` |
-//! | N-Heap | independent of data distribution | `nlogn` | `nlogn` or `n` | `n` or `1` |
+//! | N-Heap | independent of data distribution, should be faster than default heap. n = 3 | `nlogn` | `nlogn` or `n` | `n` or `1` |
 //! | Bottom-up Heap | upgraded version of heapsort with decreased number of comparisons | `nlogn` | `nlogn` or `n` | `n` or `1` |
 //! | Insertion | simple, but less effective than quicksort, heapsort or merge sort | `n`<sup>`2`</sup>; `n`<sup>`2`</sup> | `n`; `1` | `n` or `1` |
-//! | Merge | independent of data distribution | `nlogn` | `nlogn` or `n` | `n` |
+//! | Merge | independent of data distribution | `nlogn` | `nlogn` | `n` |
 //! | Odd-even | presented to be effective on processors with local interconnections | `n`<sup>`2`</sup> | `n` | `1` |
 //! | Odd-even (Batcher) | more efficient version of odd-even sort | `log`<sup>`2`</sup>`n` | `log`<sup>`2`</sup>`n` | `log`<sup>`2`</sup>`n` |
 //! | Quick | bad for sorted or reversed input | `n`<sup>`2`</sup> | `nlog`<sub>2</sub>`n` | `n` or `logn` |
+//! | Quick dual | enchanced version of quicksort | `n`<sup>`2`</sup> | `2nlnn` | `n` or `logn` |
 //! | Ksort | modified version of quicksort, faster than heap at less than 7 million elements | `n`<sup>`2`</sup> | `nlog`<sub>2</sub>`n` | `n` or `logn` |
 //! | Selection | the least number of swaps among all the algorithms | `n`<sup>`2`</sup>; `n` | `n`<sup>`2`</sup>; `1` | `1` |
-//! | Shell | it is optimization of insertion sort | `n`<sup>`2`</sup> or `nlog`<sup>`2`</sup>`n` | `nlogn` or `nlog`<sup>`2`</sup>`n` | `n` |
+//! | Shellsort | it is optimization of insertion sort | `n`<sup>`3/2`</sup> or `nlog`<sup>`2`</sup>`n` | `nlogn` | `1` |
 //! | Slow | it's slow, who would ever need it? | | | |
 //! | Smooth | variant of heapsort, good for nearly sorted data | `nlogn` | `n` | `n` or `1` |
 //! | Stooge | it's a bit faster than slow sort | `n`<sup>`2.7095`</sup> | | `n` |
@@ -49,7 +50,7 @@ pub use self::insertion_sort::insertion_sort;
 pub use self::ksort::ksort;
 pub use self::merge_sort::merge_sort;
 pub use self::oddeven_sort::{oddeven_sort, oddeven_batcher_sort};
-pub use self::quick_sort::quick_sort;
+pub use self::quick_sort::{quick_sort, quick_dual_sort};
 pub use self::selection_sort::selection_sort;
 pub use self::shell_sort::shell_sort;
 pub use self::slow_sort::slow_sort;

src/quick_sort.rs

@@ -1,7 +1,9 @@
 /// Sorts a slice in-place using
-/// [Quick sort](https://en.wikipedia.org/wiki/Quicksort).
+/// [Quick sort](https://en.wikipedia.org/wiki/Quicksort), 
+/// [Dual-Pivot Quicksort](https://www.researchgate.net/publication/259264490_Dual_pivot_Quicksort)
 /// All kinds of slices can be sorted as long as they implement
 /// [`PartialOrd`](https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html).
+/// Dual pivot quicksort additionally needs [`Copy`](https://doc.rust-lang.org/std/marker/trait.Copy.html)
 /// 
 /// Quicksort can be compared to merge sort as it also is a divide-and-conquer
 /// algorithm. However, quicksort does all the heavy work before the recursive
@@ -19,6 +21,16 @@
 /// sorting_rs::quick_sort(&mut strings);
 /// assert_eq!(strings, &["cargo", "rustc", "rustup"]);
 /// ```
+/// ```rust
+/// let mut vec = vec![0, -1, -2, -3,];
+/// sorting_rs::quick_dual_sort(&mut vec);
+/// assert_eq!(vec, &[-3, -2, -1, 0]);
+/// ```
+/// ```rust
+/// let mut strings = vec!["rustc", "cargo", "rustup"];
+/// sorting_rs::quick_dual_sort(&mut strings);
+/// assert_eq!(strings, &["cargo", "rustc", "rustup"]);
+/// ```
 
 pub fn quick_sort<T: PartialOrd>(input: &mut [T]) {
     if input.len() > 1 {
@@ -28,8 +40,8 @@ pub fn quick_sort<T: PartialOrd>(input: &mut [T]) {
     }
 }
 
-/// Partitions a slice according to the Lomuta partition scheme.
-pub fn lomuto_partition<T: PartialOrd>(input: &mut [T]) -> usize {
+/// Partitions a slice according to the Lomuto partition scheme.
+fn lomuto_partition<T: PartialOrd>(input: &mut [T]) -> usize {
     let pivot = input.len() - 1;
     let mut swap = 0;
     for i in 0..pivot {
@@ -47,6 +59,54 @@ pub fn lomuto_partition<T: PartialOrd>(input: &mut [T]) -> usize {
     swap
 }
 
+pub fn quick_dual_sort<T: PartialOrd + Copy>(input: &mut [T]) {
+    if input.len() < 2 {return;}
+    dual_pivot(input, 0, input.len() - 1);
+}
+
+fn dual_pivot<T: PartialOrd + Copy>(input: &mut [T], start: usize,
+end: usize) {
+    if start >= end {return;}
+    if input[start] > input[end] {
+        input.swap(start, end);
+    }
+    // let seventh = (input.len()) >> 3 + (input.len() >> 6) + 1;
+    let lpivot = input[start];
+    let rpivot = input[end];
+
+    let mut startm = start + 1;
+    let mut endm = end - 1;
+
+    let mut point = startm;
+
+    while point <= endm {
+        if input[point] < lpivot {
+            input.swap(point, startm);
+            startm += 1;
+        }
+        else if input[point] >= rpivot {
+            while input[endm] > rpivot && point < endm {
+                endm -= 1;
+            }
+            input.swap(point, endm);
+
+            if input[point] < lpivot {
+                input.swap(point, startm);
+                startm += 1;
+            }
+        }
+        point += 1;
+    }
+    startm -= 1;
+    endm += 1;
+    input.swap(start, startm);
+    input.swap(end, endm);
+
+    dual_pivot(input, start, startm);
+    dual_pivot(input, startm + 1, endm);
+    dual_pivot(input, endm, end);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -69,4 +129,34 @@ mod tests {
         quick_sort(&mut vector_in);
         debug_assert_eq!(vector_in, vec![1]);
     }
+    #[test]
+    fn test_quick_dual() {
+        let mut vector_in = vec![10, 20, 11, 24];
+        quick_dual_sort(&mut vector_in);
+        debug_assert_eq!(vector_in, vec![10, 11, 20, 24]);
+    }
+    #[test]
+    fn test_quick_two_elem() {
+        let mut vector_in = [20, 10];
+        quick_dual_sort(&mut vector_in);
+        debug_assert_eq!(vector_in, [10, 20]);
+    }
+    #[test]
+    fn test_quick_dual_longer() {
+        let mut vector_in = [10, 20, 11, 24, 22, 21, 19];
+        quick_dual_sort(&mut vector_in);
+        debug_assert_eq!(vector_in, [10, 11, 19, 20, 21, 22, 24]);
+    }
+    #[test]
+    fn test_quick_dual_empty() {
+        let mut vector_in:Vec<i32> = vec![];
+        quick_dual_sort(&mut vector_in);
+        debug_assert_eq!(vector_in, &[]);
+    }
+    #[test]
+    fn test_quick_dual_len1() {
+        let mut vector_in = vec![1];
+        quick_dual_sort(&mut vector_in);
+        debug_assert_eq!(vector_in, vec![1]);
+    }
 }