added merge sort iterative algorithm

Author: marioplumbarius

README.md

@@ -35,7 +35,9 @@ gradle clean assemble
 - [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)
-- [Merge Sort](https://github.com/marioluan/java-sorting-algorithms/blob/master/src/main/java/io/github/marioluan/algorithms/sorting/MergeSort.java)
+- Merge Sort
+-- [Recursive](https://github.com/marioluan/java-sorting-algorithms/blob/master/src/main/java/io/github/marioluan/algorithms/sorting/MergeSortRecursive.java)
+-- [Iterative](https://github.com/marioluan/java-sorting-algorithms/blob/master/src/main/java/io/github/marioluan/algorithms/sorting/MergeSortIterative.java)
 
 ## References
 - [https://www.coursera.org/learn/algorithms-part1](https://www.coursera.org/learn/algorithms-part1)

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

@@ -0,0 +1,75 @@
+package io.github.marioluan.algorithms.sorting;
+
+/**
+ * Iterative stable implementation of merge sort algorithm. <br>
+ * <strong>Time complexity:</strong> O(N log N) <br>
+ * <strong>Space complexity:</strong> O(n) <br>
+ * References:
+ * <ul>
+ * <li><a>https://www.coursera.org/learn/algorithms-part1</a>.</li>
+ * <li><a>https://upload.wikimedia.org/wikipedia/commons/c/cc/Merge-sort-example-300px.gif</a></li>
+ * </ul>
+ * 
+ * @author marioluan
+ */
+public final class MergeSortIterative extends Sortable {
+
+    private MergeSortIterative() {
+    }
+
+    /**
+     * Sort items from array a.
+     * 
+     * @param a
+     */
+    @SuppressWarnings("rawtypes")
+    public static void sort(Comparable[] a) {
+        Comparable[] aux = new Comparable[a.length];
+        sort(a, aux);
+    };
+
+    /**
+     * Iteratively sort items from array a.
+     * 
+     * @param a
+     * @param aux
+     * @param lo
+     * @param hi
+     */
+    @SuppressWarnings("rawtypes")
+    private static void sort(Comparable[] a, Comparable[] aux) {
+        int n = a.length;
+        for (int size = 1; size < n; size = size + size)
+            for (int lo = 0; lo < n - size; lo += size + size)
+                merge(a, aux, lo, lo + size - 1,
+                        Math.min(lo + size + size - 1, n - 1));
+    }
+
+    /**
+     * Merge sorted sub-arrays a and aux.
+     * 
+     * @param a
+     * @param aux
+     * @param lo
+     * @param mid
+     * @param hi
+     */
+    @SuppressWarnings("rawtypes")
+    private static void merge(Comparable[] a, Comparable[] aux, int lo, int mid,
+            int hi) {
+        copy(a, aux, lo, hi);
+        int i = lo;
+        int j = mid + 1;
+
+        for (int k = lo; k <= hi; k++) {
+            if (i > mid)
+                a[k] = aux[j++];
+            else if (j > hi)
+                a[k] = aux[i++];
+            else if (lessOrEqual(aux[j], aux[i]))
+                a[k] = aux[j++];
+            else
+                a[k] = aux[i++];
+        }
+    }
+}

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