added selection sort algorithm

Author: marioplumbarius

src/main/java/io/github/marioluan/algorithms/sorting/SelectionSort.java

@@ -0,0 +1,34 @@
+package io.github.marioluan.algorithms.sorting;
+
+/**
+ * In-place, non-stable implementation of selection sort algorithm. <br>
+ * <strong>Time complexity:</strong> O(N^2) <br>
+ * <strong>Space complexity:</strong> O(1) <br>
+ * References:
+ * <ul>
+ * <li><a>https://www.coursera.org/learn/algorithms-part1</a>.</li>
+ * <li><a>https://upload.wikimedia.org/wikipedia/commons/b/b0/Selection_sort_animation.gif</a></li>
+ * </ul>
+ * 
+ * @author marioluan
+ */
+public final class SelectionSort extends Sortable {
+
+    private SelectionSort() {
+    }
+
+    /**
+     * Sort the elements from array a.
+     * 
+     * @param a
+     */
+    @SuppressWarnings("rawtypes")
+    public static void sort(Comparable[] a) {
+        int n = a.length;
+
+        for (int i = 0; i < n; i++) {
+            int min = findMin(a, i, n);
+            swap(a, i, min);
+        }
+    }
+}

src/test/java/io/github/marioluan/algorithms/sorting/SelectionSortTest.java

@@ -0,0 +1,78 @@
+package io.github.marioluan.algorithms.sorting;
+
+import static org.junit.Assert.assertArrayEquals;
+import static com.greghaskins.spectrum.Spectrum.describe;
+import static com.greghaskins.spectrum.Spectrum.beforeEach;
+import static com.greghaskins.spectrum.Spectrum.it;
+
+import java.util.Arrays;
+import java.util.Random;
+
+import org.junit.runner.RunWith;
+
+import com.greghaskins.spectrum.Spectrum;
+
+import io.github.marioluan.algorithms.test.support.SupportHelper;
+
+@SuppressWarnings("rawtypes")
+@RunWith(Spectrum.class)
+public class SelectionSortTest {
+
+    private static final Random RANDOM = new Random();
+    private Comparable[]        array  = null;
+    private Comparable[]        clone  = null;
+    private int                 n      = 0;
+
+    {
+        describe("InsertionSort", () -> {
+            describe(".sort", () -> {
+
+                describe("when array is small", () -> {
+                    beforeEach(() -> {
+                        n = RANDOM.nextInt(7) + 1;
+                        array = SupportHelper.buildRandomArray(n);
+                        clone = array.clone();
+                    });
+
+                    it("sorts it", () -> {
+                        Arrays.sort(clone);
+                        SelectionSort.sort(array);
+
+                        assertArrayEquals(array, clone);
+                    });
+                });
+
+                describe("when array is huge", () -> {
+                    beforeEach(() -> {
+                        n = RANDOM.nextInt((int) Math.pow(10, 5)) + 1;
+                        array = SupportHelper.buildRandomArray(n);
+                        clone = array.clone();
+                    });
+
+                    it("sorts it", () -> {
+                        Arrays.sort(clone);
+                        SelectionSort.sort(array);
+
+                        assertArrayEquals(array, clone);
+                    });
+                });
+
+                describe("when array is partially sorted", () -> {
+                    beforeEach(() -> {
+                        array = new Comparable[] { 1, 2, 3, 6, 9, 5, 10, 4, 11,
+                                13, 14, 15, 16, 17, 18, 19, 20 };
+                        clone = array.clone();
+                    });
+
+                    it("sorts it", () -> {
+                        Arrays.sort(clone);
+                        SelectionSort.sort(array);
+
+                        assertArrayEquals(array, clone);
+                    });
+                });
+
+            });
+        });
+    }
+}