.drone.yml

@@ -1,5 +0,0 @@
-pipeline:
-        build:
-                image: rust
-                commands:
-                        - cargo run

CHANGELOG.md

@@ -1,40 +1,3 @@
-<a name="v0.5.1"></a>
-### v0.5.1 (2017-09-15)
-
-This release only is the addition of CI for test purposes.
-
-
-<a name="v0.5.0"></a>
-## v0.5.0 (2017-08-29)
-
-
-#### Features
-
-*   add insertionsort ([cb03ff51](cb03ff51))
-*   demo all algorithms ([198e1544](198e1544), closes [#2](2) (and also [#1](1)))
-
-
-
-<a name="v0.4.0"></a>
-## v0.4.0 (2017-08-27)
-
-
-#### Features
-
-*   add quicksort ([b607608b](b607608b))
-
-
-
-<a name="v0.3.0"></a>
-## v0.3.0 (2017-08-27)
-
-
-#### Features
-
-*   add insertionsort ([6659387d](6659387d))
-
-
-
 <a name="v0.2.0"></a>
 ## v0.2.0 (2017-08-27)
 

Cargo.lock

@@ -1,4 +1,4 @@
 [root]
-name = "algo"
+name = "sorting"
-version = "0.5.0"
+version = "0.1.0"
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "algo"
+name = "sorting"
-version = "0.5.1"
+version = "0.1.0"
 authors = ["Jan Christian Grünhage <jan.christian@gruenhage.xyz>"]
 
 [dependencies]

README.md

@@ -1,3 +1 @@
 Just some sorting algorithm implementations as practice for an exam. If they are useful for you, feel free to use them, under the included license.
-
-[![Build Status](https://drone.jcg.re/api/badges/jcgruenhage/algo/status.svg)](https://drone.jcg.re/jcgruenhage/algo)

src/algorithms/bubblesort.rs

@@ -1,8 +1,8 @@
-use sorting::Algorithm;
+use algorithms::Algorithm;
 
-pub struct Sort;
+pub struct Bubblesort;
 
-impl Algorithm for Sort {
+impl Algorithm for Bubblesort {
     fn sort(mut vector: Vec<i32>) -> Result<Vec<i32>, &'static str> {
         for i in 0..(vector.len()) {
             for j in 0..(vector.len() - i - 1) {
@@ -15,4 +15,4 @@ impl Algorithm for Sort {
         }
         return Ok(vector);
     }
-}
+}

src/algorithms/mergesort.rs

@@ -1,8 +1,8 @@
-use sorting::Algorithm;
+use algorithms::Algorithm;
 
-pub struct Sort;
+pub struct Mergesort;
 
-impl Algorithm for Sort {
+impl Algorithm for Mergesort {
     fn sort(mut vector: Vec<i32>) -> Result<Vec<i32>, &'static str> {
         if vector.len() == 1 {
             return Ok(vector);
@@ -17,13 +17,13 @@ impl Algorithm for Sort {
                     }
                 });
             }
-            let first = match Sort::sort(vector) {
+            let first = match Mergesort::sort(vector) {
                 Ok(v) => v,
-                Err(e) => return Err(e),
+                Err(e) => return Err(e)
             };
-            second = match Sort::sort(second) {
+            second = match Mergesort::sort(second) {
                 Ok(v) => v,
-                Err(e) => return Err(e),
+                Err(e) => return Err(e)
             };
 
             let mut result: Vec<i32> = Vec::new();
@@ -57,4 +57,4 @@ impl Algorithm for Sort {
             return Ok(result);
         }
     }
-}
+}

src/algorithms/mod.rs

@@ -0,0 +1,7 @@
+pub trait Algorithm {
+    fn sort(vector: Vec<i32>) -> Result<Vec<i32>, &'static str>;
+}
+
+
+pub mod bubblesort;
+pub mod mergesort;

src/main.rs

@@ -1,82 +1,16 @@
-mod sorting;
+mod algorithms;
 
-use sorting::*;
+use algorithms::mergesort::Mergesort;
-use sorting::Algorithm;
+use algorithms::Algorithm;
 
 fn main() {
-    demo_sorting();
+    let unsorted : Vec<i32> = vec![2498,29687,24,5,94545,8,51,152,48,871,5];
-}
+    let sorted = match Mergesort::sort(unsorted) {
-
+        Ok(v) => v,
-fn demo_sorting() {
+        Err(e) => {
-    let unsorted: Vec<i32> = vec![
+            println!("Something went wrong! {}", e);
-        2498,
+            return;
-        29687,
-        24,
-        94545,
-        8,
-        51,
-        152,
-        871,
-        5,
-        6557,
-        216,
-        75986,
-        48,
-        526,
-        15,
-        6,
-        78,
-    ];
-
-    println!("Unsorted array: {:?}", unsorted);
-    println!(
-        "Bubblesort    : {:?}",
-        match bubble::Sort::sort(unsorted.clone()) {
-            Ok(v) => v,
-            Err(e) => {
-                println!("Something went wrong! {}", e);
-                return;
-            }
         }
-    );
+    };
-    println!(
+    println!("{:?}", sorted);
-        "Selectionsort : {:?}",
+}
-        match selection::Sort::sort(unsorted.clone()) {
-            Ok(v) => v,
-            Err(e) => {
-                println!("Something went wrong! {}", e);
-                return;
-            }
-        }
-    );
-    println!(
-        "Insertionsort : {:?}",
-        match insertion::Sort::sort(unsorted.clone()) {
-            Ok(v) => v,
-            Err(e) => {
-                println!("Something went wrong! {}", e);
-                return;
-            }
-        }
-    );
-    println!(
-        "Mergesort     : {:?}",
-        match merge::Sort::sort(unsorted.clone()) {
-            Ok(v) => v,
-            Err(e) => {
-                println!("Something went wrong! {}", e);
-                return;
-            }
-        }
-    );
-    println!(
-        "Quicksort     : {:?}",
-        match quick::Sort::sort(unsorted.clone()) {
-            Ok(v) => v,
-            Err(e) => {
-                println!("Something went wrong! {}", e);
-                return;
-            }
-        }
-    );
-}

src/sorting/insertion.rs

@@ -1,17 +0,0 @@
-use sorting::*;
-
-pub struct Sort;
-
-impl Algorithm for Sort {
-    fn sort(mut vector: Vec<i32>) -> Result<Vec<i32>, &'static str> {
-        for i in 0..vector.len() {
-            for j in 0..(i) {
-                if vector[j] > vector[i] {
-                    vector = rotate(vector, j, i);
-                    break;
-                }
-            }
-        }
-        return Ok(vector);
-    }
-}

src/sorting/mod.rs

@@ -1,21 +0,0 @@
-pub trait Algorithm {
-    fn sort(vector: Vec<i32>) -> Result<Vec<i32>, &'static str>;
-}
-
-
-pub mod bubble;
-pub mod merge;
-pub mod selection;
-pub mod quick;
-pub mod insertion;
-
-pub fn rotate(mut vector: Vec<i32>, from: usize, to: usize) -> Vec<i32> {
-    if from != to {
-        let to_value = vector[to];
-        for j in (from..(to)).rev() {
-            vector[j + 1] = vector[j];
-        }
-        vector[from] = to_value;
-    }
-    return vector;
-}

src/sorting/quick.rs

@@ -1,59 +0,0 @@
-use sorting::Algorithm;
-
-pub struct Sort;
-
-impl Algorithm for Sort {
-    fn sort(mut vector: Vec<i32>) -> Result<Vec<i32>, &'static str> {
-        let pivot = match vector.pop() {
-            Some(v) => v,
-            None => return Ok(Vec::new()),
-        };
-        let mut pivots: Vec<i32> = Vec::new();
-        pivots.push(pivot);
-
-        let mut smaller: Vec<i32> = Vec::new();
-        let mut larger: Vec<i32> = Vec::new();
-
-        while vector.len() != 0 {
-            let element = match vector.pop() {
-                Some(v) => v,
-                None => {
-                    return Err(
-                        "Vector had a length not equal to 0, but still had no more element in it. This point should not be reachable.",
-                    )
-                }
-            };
-            if element < pivot {
-                smaller.push(element);
-            } else if element > pivot {
-                larger.push(element);
-            } else {
-                pivots.push(element);
-            }
-        }
-
-        let mut result: Vec<i32> = Vec::new();
-
-        for v in match Sort::sort(smaller) {
-            Ok(v) => v,
-            Err(e) => return Err(e),
-        }
-        {
-            result.push(v);
-        }
-
-        for v in pivots {
-            result.push(v);
-        }
-
-        for v in match Sort::sort(larger) {
-            Ok(v) => v,
-            Err(e) => return Err(e),
-        }
-        {
-            result.push(v);
-        }
-
-        return Ok(result);
-    }
-}

src/sorting/selection.rs

@@ -1,18 +0,0 @@
-use sorting::*;
-
-pub struct Sort;
-
-impl Algorithm for Sort {
-    fn sort(mut vector: Vec<i32>) -> Result<Vec<i32>, &'static str> {
-        for i in 0..vector.len() {
-            let mut smallest_index = i;
-            for j in i..vector.len() {
-                if vector[j] < vector[smallest_index] {
-                    smallest_index = j;
-                }
-            }
-            vector = rotate(vector, i, smallest_index);
-        }
-        return Ok(vector);
-    }
-}

src/sorting/template.rs

@@ -1,9 +0,0 @@
-use sorting::Algorithm;
-
-pub struct Sort;
-
-impl Algorithm for Sort {
-    fn sort(mut vector: Vec<i32>) -> Result<Vec<i32>, &'static str> {
-        return Mergesort::sort(vector);
-    }
-}