added shellsort algorithm

Author: marioplumbarius

README.md

@@ -34,6 +34,7 @@ gradle clean assemble
 ## Available algorithms
 - [Insertion Sort](https://github.com/marioluan/java-sorting-algorithms/blob/master/src/main/java/io/github/marioluan/algorithms/sorting/InsertionSort.java)
 - [Selection Sort](https://github.com/marioluan/java-sorting-algorithms/blob/master/src/main/java/io/github/marioluan/algorithms/sorting/SelectionSort.java)
+- [Shellsort](https://github.com/marioluan/java-sorting-algorithms/blob/master/src/main/java/io/github/marioluan/algorithms/sorting/ShellSort.java)
 
 ## References
 - [https://www.coursera.org/learn/algorithms-part1](https://www.coursera.org/learn/algorithms-part1)

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

@@ -0,0 +1,46 @@
+package io.github.marioluan.algorithms.sorting;
+
+/**
+ * In-place, non-stable implementation of shellsort algorithm. <br>
+ * <strong>Time complexity:</strong> O(N^1.5) <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/d/d8/Sorting_shellsort_anim.gif</a></li>
+ * </ul>
+ * 
+ * @author marioluan
+ */
+public class ShellSort extends Sortable {
+
+    private static final int C = 3;
+
+    /**
+     * Sort the items from array a.
+     * 
+     * @param a
+     */
+    @SuppressWarnings("rawtypes")
+    public static void sort(Comparable[] a) {
+        int n = a.length;
+        int h = 1;
+
+        // 3x+1 increment sequence
+        while (h < n / C)
+            h = (C * h) + 1; // 1, 4, 13, 40, 121, 363, ...
+
+        while (h >= 1) {
+            // h-sort the array
+            // insertion sort
+            for (int i = h; i < n; i++) {
+                for (int j = i; j >= h && less(a[j], a[j - h]); j = j - h)
+                    swap(a, j, j - h);
+
+            }
+
+            h = h / C;
+        }
+
+    }
+}

src/test/java/io/github/marioluan/algorithms/sorting/ShellSortTest.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 ShellSortTest {
+
+    private static final Random RANDOM = new Random();
+    private Comparable[]        array  = null;
+    private Comparable[]        clone  = null;
+    private int                 n      = 0;
+
+    {
+        describe("ShellSort", () -> {
+            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);
+                        ShellSort.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);
+                        ShellSort.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);
+                        ShellSort.sort(array);
+
+                        assertArrayEquals(array, clone);
+                    });
+                });
+
+            });
+        });
+    }
+}