Implement sorting algorithms with trait and example sorters. M;ade sk… (#9)

…eletons for QuickSort and MergeSort.

Author: Fritzoid

src/algorithm.rs

@@ -0,0 +1,72 @@
+pub trait SortingAlgorithm {
+    type Input;
+    type Output;
+
+    fn run(&self, input: Self::Input) -> Self::Output;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct ArraySorter;
+    impl SortingAlgorithm for ArraySorter {
+        type Input = [i32; 3];
+        type Output = [i32; 3];
+
+        fn run(&self, input: [i32; 3]) -> [i32; 3] {
+            let mut output = input;
+            output.sort();
+            output
+        }
+    }
+
+    struct StringSorter;
+    impl SortingAlgorithm for StringSorter {
+        type Input = String;
+        type Output = String;
+
+        fn run(&self, input: String) -> String {
+            let mut output = input.chars().collect::<Vec<char>>();
+            output.sort();
+            output.into_iter().collect()
+        }
+    }
+
+    struct VectorSorter;
+    impl SortingAlgorithm for VectorSorter {
+        type Input = Vec<i32>;
+        type Output = Vec<i32>;
+
+        fn run(&self, input: Vec<i32>) -> Vec<i32> {
+            let mut output = input;
+            output.sort();
+            output
+        }
+    }
+
+    #[test]
+    fn test_array_sorter() {
+        let sorter = ArraySorter;
+        let input = [3, 2, 1];
+        let output = sorter.run(input);
+        assert_eq!(output, [1, 2, 3]);
+    }
+
+    #[test]
+    fn test_string_sorter() {
+        let sorter = StringSorter;
+        let input = "cba".to_string();
+        let output = sorter.run(input);
+        assert_eq!(output, "abc");
+    }
+
+    #[test]
+    fn test_vector_sorter() {
+        let sorter = VectorSorter;
+        let input = vec![3, 2, 1];
+        let output = sorter.run(input);
+        assert_eq!(output, vec![1, 2, 3]);
+    }
+
+}

src/main.rs

@@ -1,3 +1,16 @@
+mod algorithm;
+mod quicksort;
+mod mergesort;
+
+use algorithm::SortingAlgorithm;
+use quicksort::QuickSort;
+use mergesort::MergeSort;
+
 fn main() {
-    println!("Hello, world!");
+    let sorting_algorithms: Vec<Box<dyn SortingAlgorithm<Input = Vec<i32>, Output = Vec<i32>>>> = vec![Box::new(QuickSort), Box::new(MergeSort)];
+    sorting_algorithms.iter().for_each(|sorting_algorithm| {
+        let input = vec![3, 2, 1];
+        let output = sorting_algorithm.run(input);
+        println!("{:?}", output);
+    });
 }

src/mergesort.rs

@@ -0,0 +1,11 @@
+use crate::algorithm::SortingAlgorithm;
+
+pub struct MergeSort;
+impl SortingAlgorithm for MergeSort {
+    type Input = Vec<i32>;
+    type Output = Vec<i32>;
+
+    fn run(&self, mut input: Vec<i32>) -> Vec<i32> {
+        input
+    }
+}

src/quicksort.rs

@@ -0,0 +1,11 @@
+use crate::algorithm::SortingAlgorithm;
+
+pub struct QuickSort;
+impl SortingAlgorithm for QuickSort {
+    type Input = Vec<i32>;
+    type Output = Vec<i32>;
+
+    fn run(&self, mut input: Vec<i32>) -> Vec<i32> {
+        input
+    }
+}