sorter 0.4.0

Simple rust implementation of all existing sorts
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

extern crate sorter;
extern crate rand;
use sorter::*;
use rand::{Rng, thread_rng};

fn check_order<T: Ord>(array: &mut [T]) -> bool {
    for i in 1..array.len() { if array[i-1] > array[i] { return false; } }
    true
}

fn make_test_vec() -> Vec<Vec<i32>> {
    let mut make_test_vec = vec![10, 5, 1, 2, 4];
    let mut main_vec = vec![make_test_vec];

    make_test_vec = vec![1, 2, 3, 4, 5, 6, 7];
    main_vec.push(make_test_vec);
    make_test_vec = vec![1, 2, 3, 4, 5, 6];
    main_vec.push(make_test_vec);
    make_test_vec = vec![7, 6, 5, 4, 3, 2, 1];
    main_vec.push(make_test_vec);
    make_test_vec = vec![5, 10, 1, 3, 5, 2, 3];
    main_vec.push(make_test_vec);
    make_test_vec = thread_rng().gen_iter::<i32>().take(1000).collect::<Vec<i32>>();
    main_vec.push(make_test_vec);
    make_test_vec = thread_rng().gen_iter::<i32>().take(555).collect::<Vec<i32>>();
    main_vec.push(make_test_vec);

    main_vec
}

#[test]
fn verify_insertion_sort() {
    let mut main_vec = make_test_vec();

    println!("Usual:");
    for array in main_vec.iter_mut() {
        insertion_sort(array);
        if !check_order(array) {
            println!("Incorrectly ordered array: {:?}", array);
            assert!(false);
        }
    }

    main_vec = make_test_vec();
    println!("Binary:");
    for array in main_vec.iter_mut() {
        println!("{:?}", array);
        binary_insertion_sort(array);
        if !check_order(array) {
            println!("Incorrectly ordered array: {:?}", array);
            assert!(false);
        }
    }
}

#[test]
fn verify_quick_sort() {
    let mut main_vec = make_test_vec();

    for array in main_vec.iter_mut() {
        quick_sort(array);
        if !check_order(array) {
            println!("Incorrectly ordered array: {:?}", array);
            assert!(false);
        }
    }
}

#[test]
fn verify_heap_sort() {
    let mut main_vec = make_test_vec();

    for array in main_vec.iter_mut() {
        heap_sort(array);
        if !check_order(array) {
            println!("Incorrectly ordered array: {:?}", array);
            assert!(false);
        }
    }
}

#[test]
fn verify_shaker_sort() {
    let mut main_vec = make_test_vec();

    for array in main_vec.iter_mut() {
        shaker_sort(array);
        if !check_order(array) {
            println!("Incorrectly ordered array: {:?}", array);
            assert!(false);
        }
    }
}

#[test]
fn verify_shell_sort() {
    let mut main_vec = make_test_vec();

    for array in main_vec.iter_mut() {
        shell_sort(array);
        if !check_order(array) {
            println!("Incorrectly ordered array: {:?}", array);
            assert!(false);
        }
    }
}

#[test]
fn verify_bubble_sort() {
    let mut main_vec = make_test_vec();

    for array in main_vec.iter_mut() {
        bubble_sort(array);
        if !check_order(array) {
            println!("Incorrectly ordered array: {:?}", array);
            assert!(false);
        }
    }
}