Added ksort algorithm, bumped version and edited docs

Author: flakusha

Cargo.toml

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

README.md

@@ -20,7 +20,7 @@ please read modules documentation
 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() |
-| ------ | -------------------------------- | ------------------------------------ | -------- | ---------- |
+| -------------- | -------------------------------- | -------- | -------- | ------------- |
 | Bubble | bad for sorted or reversed input | `n`<sup>`2`</sup>; `n`<sup>`2`</sup> | `n`; `1` | `n` or `1` |
 | Cocktail | little performance improvement over bubble sort | `n`<sup>`2`</sup> | `n` | `1` |
 | Comb | speeds up when data is nearly sorted | `n`<sup>`2`</sup> | `nlogn` | `1` |
@@ -33,7 +33,8 @@ New algorithms implementations are planned
 | Merge | independent of data distribution | `nlogn` | `nlogn` or `n` | `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> | `n` | `n` or `logn` |
+| Quick | bad for sorted or reversed input | `n`<sup>`2`</sup> | `nlog`<sub>2</sub>`n` | `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` |
 | Slow | it's slow, who would ever need it? | | | |

benches/sort_benchmark.rs

@@ -30,7 +30,7 @@ macro_rules! create_bench {
 }
 
 fn bench(c: &mut Criterion) {
-    let sizes: Vec<usize> = vec![10, 100, 1000, 10_000, /*100_000, 1_000_000,
+    let sizes: Vec<usize> = vec![10, 100, 1000, 10_000, 100_000, /* 1_000_000,
     10_000_000*/];
 
     let benchmark = create_bench! {
@@ -43,6 +43,7 @@ fn bench(c: &mut Criterion) {
         heap_bottom_up_sort,
         weak_heap_sort,
         insertion_sort,
+        ksort,
         merge_sort,
         nheap_sort,
         oddeven_sort,

src/ksort.rs

@@ -0,0 +1,95 @@
+/// Sorts a slice in-place using
+/// [K-sort](https://arxiv.org/abs/1107.3622)
+/// 
+/// This sorting algorithm is in fact a modification of quick sort which should
+/// be faster than quicksort for arrays with less than 7 million elements
+/// This algorithm is generally compared to heapsort and quicksort, it doesn't
+/// need to construct the heap and generally wins in benchmarks because of this
+/// 
+/// # Examples
+/// ```rust
+/// let mut vec = vec![5, 2, 7, 3, 9];
+/// sorting_rs::ksort(&mut vec);
+/// debug_assert_eq!(vec, &[2, 3, 5, 7, 9]);
+/// ```
+/// ```rust
+/// let mut strings = vec!["rustc", "cargo", "rustup"];
+/// sorting_rs::ksort(&mut strings);
+/// assert_eq!(strings, &["cargo", "rustc", "rustup"]);
+/// ```
+
+pub fn ksort<T: PartialOrd + Clone + Copy>(input: &mut [T]) {
+    if input.len() < 2 {return;}
+    ksort_lr(input, 0, input.len() - 1);
+}
+
+fn ksort_lr<T: PartialOrd + Clone + Copy>(input: &mut [T], left: usize,
+right: usize) {
+    let key = input[left].clone();
+    // just init it, so no unsafe calls needed, otherwise use of uninit
+    // is prohibited by Rust compiler
+    let mut temp = key.clone();
+    let mut i = left;
+    let mut j = right + 1;
+    let mut k = i + 1;
+    let mut p = i + 1;
+    let mut flag = false;
+
+    while j - i >= 2 {
+        if key <= input[p] {
+            if p != j && j != right + 1 {
+                input.swap(j, p);
+            } else if j == right + 1 {
+                flag = true;
+                temp = input[p].clone();
+            }
+            j -= 1;
+            p = j;
+        } else {
+            input.swap(i, p);
+            i += 1;
+            k += 1;
+            p = k;
+        }
+    }
+
+    input[i] = key;
+    if flag {input[i + 1] = temp;}
+
+    if left < i.saturating_sub(1) {
+        ksort_lr(input, left, i - 1);
+    }
+    if right > i + 1 {
+        ksort_lr(input, i + 1, right);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_ksort() {
+        let mut vector_in = [10, 20, 11, 24];
+        ksort(&mut vector_in);
+        debug_assert_eq!(vector_in, [10, 11, 20, 24]);
+    }
+    #[test]
+    fn test_ksort_01() {
+        let mut vector_in = [10, 9, 20, 22, 11, 21, 12, 24, 4, 6, 3];
+        ksort(&mut vector_in);
+        debug_assert_eq!(vector_in, [3, 4, 6, 9, 10, 11, 12, 20, 21, 22, 24]);
+    }
+    #[test]
+    fn test_ksort_empty() {
+        let mut vector_in:Vec<i32> = vec![];
+        ksort(&mut vector_in);
+        debug_assert_eq!(vector_in, &[]);
+    }
+    #[test]
+    fn test_ksort_len1() {
+        let mut vector_in = vec![1];
+        ksort(&mut vector_in);
+        debug_assert_eq!(vector_in, vec![1]);
+    }
+}

src/lib.rs

@@ -14,7 +14,8 @@
 //! | Merge | independent of data distribution | `nlogn` | `nlogn` or `n` | `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> | `n` | `n` or `logn` |
+//! | Quick | bad for sorted or reversed input | `n`<sup>`2`</sup> | `nlog`<sub>2</sub>`n` | `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` |
 //! | Slow | it's slow, who would ever need it? | | | |
@@ -27,6 +28,7 @@ pub mod comb_sort;
 pub mod gnome_sort;
 pub mod heap_sort;
 pub mod insertion_sort;
+pub mod ksort;
 pub mod merge_sort;
 pub mod nheap_sort;
 pub mod oddeven_sort;
@@ -44,6 +46,7 @@ pub use self::gnome_sort::gnome_sort;
 pub use self::heap_sort::{heap_sort, heap_bottom_up_sort, weak_heap_sort};
 pub use self::nheap_sort::nheap_sort;
 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;