sort.rs

mod sort_fn {
    pub fn bubble_sort<T: Ord>(victim: &mut [T]) {
        for _ in 0..victim.len() {
            for j in 1..victim.len() {
                if victim[j - 1] > victim[j] {
                    victim.swap(j - 1, j);
                }
            }
        }
    }

    pub fn inerted_sort<T: Ord>(victim: &mut [T]) {
        for i in 0..victim.len() {
            for j in 1..i {
                if victim[j - 1] > victim[j] {
                    victim.swap(j - 1, j);
                }
            }
        }
    }

    pub fn shake_sort<T: Ord>(victim: &mut [T]) {
        let len = victim.len() - 1;

        for left in 0..len {
            for i in left..len {
                if victim[i + 1] < victim[i] {
                    victim.swap(i + 1, i);
                }
            }

            for i in len..left {
                if victim[i + 1] > victim[i] {
                    victim.swap(i + 1, i);
                }
            }
        }
    }

    pub fn odd_even_sort<T: Ord>(victim: &mut [T]) {
        let mut flag = false;
        let is_odd = |x: usize| x % 2 != 0;
        let is_even = |x: usize| x % 2 == 0;

        for _ in 0..victim.len() {
            {
                let condition = |index: usize| if flag { is_even(index) } else { is_odd(index) };

                for j in 1..victim.len() {
                    if condition(j - 1) && victim[j - 1] > victim[j] {
                        victim.swap(j - 1, j);
                    }
                }
            }

            flag = !flag;
        }
    }

    pub fn comb_sort<T: Ord>(victim: &mut [T]) {
        let reduction_factor: f64 = 1.24;
        let len = victim.len() - 1;
        let mut toggle_len = len.clone();
        let mut count = 1;

        for _ in 0..len {
            let step = (toggle_len as f64 / reduction_factor).ceil() as usize;

            for j in 0..count {
                if victim[j + step] < victim[j] {
                    victim.swap(j + step, j);
                }
            }

            toggle_len = toggle_len - 1;
            count = count + 1;
        }
    }
}

fn main() {
    let mut data: Vec<i32> = vec![1, 8, 7, 9, 15, 12, 11, 2, 3, 5, 6];

    sort_fn::comb_sort(&mut data);

    println!("{:?}", data);
}