docs: update changelog

Add demo code for all currently implemented algorithms, as well as a refactoring of the package structure.
Rename of the mistakenly called insertion sort, which was actually selection sort.

Fixes #1 and Fixes #2

.drone.yml

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

CHANGELOG.md

@@ -1,3 +1,30 @@
+<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)
 

Cargo.lock

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

Cargo.toml

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

README.md

@@ -1 +1,3 @@
 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/insertionsort.rs

@@ -1,25 +0,0 @@
-use algorithms::Algorithm;
-
-pub struct Insertionsort;
-
-impl Algorithm for Insertionsort {
-    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;
-                }
-            }
-            if i != smallest_index {
-                let smallest_value = vector[smallest_index];
-                for j in (i..(smallest_index)).rev() {
-                    vector[j + 1] = vector[j];
-                }
-                vector[i] = smallest_value;
-            }
-            println!("{:?}", vector);
-        }
-        return Ok(vector);
-    }
-}

src/algorithms/mod.rs

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

src/main.rs

@@ -1,16 +1,82 @@
-mod algorithms;
+mod sorting;
 
-use algorithms::insertionsort::Insertionsort;
-use algorithms::Algorithm;
+use sorting::*;
+use sorting::Algorithm;
 
 fn main() {
-    let unsorted: Vec<i32> = vec![2498, 29687, 24, 5, 94545, 8, 51, 152, 48, 871, 5];
-    let sorted = match Insertionsort::sort(unsorted) {
-        Ok(v) => v,
-        Err(e) => {
-            println!("Something went wrong! {}", e);
-            return;
-        }
-    };
-    println!("{:?}", sorted);
+    demo_sorting();
+}
+
+fn demo_sorting() {
+    let unsorted: Vec<i32> = vec![
+        2498,
+        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!(
+        "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/bubble.rs

@@ -1,8 +1,8 @@
-use algorithms::Algorithm;
+use sorting::Algorithm;
 
-pub struct Bubblesort;
+pub struct Sort;
 
-impl Algorithm for Bubblesort {
+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..(vector.len() - i - 1) {

src/sorting/insertion.rs

@@ -0,0 +1,17 @@
+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/merge.rs

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

src/sorting/mod.rs

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,9 @@
+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);
+    }
+}