Added mergesort iterative int implementation

Author: kaitinghh

src/algorithms/sorting/mergeSort/iterative/MergeSort.java

@@ -1,4 +1,116 @@
 package src.algorithms.sorting.mergeSort.iterative;
 
+/** Here, we are implementing MergeSort where we sort the array in increasing (or more precisely, non-decreasing)
+ * order iteratively.
+ *
+ * Brief Description:
+ * The iterative implementation of MergeSort takes a bottom-up approach, where the sorting process starts by merging
+ * intervals of size 1. Intervals of size 1 are trivially in sorted order. The algorithm then proceeds to merge
+ * adjacent sorted intervals, doubling the interval size with each merge step, until the entire array is fully sorted.
+ *
+ * Implementation Invariant:
+ * At each iteration of the merging process, the main array is divided into sub-arrays of a certain interval
+ * size (<interval>). Each of these sub-arrays is sorted within itself. The last sub-array may not be of size
+ * <interval> but it is still sorted since its size is necessarily less than <interval>.
+ *
+ * Complexity Analysis:
+ * Time:
+ * - Worst case: O(nlogn)
+ * - Average case: O(nlogn)
+ * - Best case: O(nlogn)
+ *
+ * Given two sorted arrays of size p and q, we need O(p + q) time to merge the two arrays into one sorted array, since
+ * we have to iterate through every element in both arrays once.
+ *
+ * At the 1st level of the merge process, our merging subroutine involves n sub-arrays of size 1, taking O(n) time.
+ * At the 2nd level of the merge process, our merging subroutine involves (n/2) sub-arrays of size 2, taking O(n) time.
+ * At the kth level of the merge process, our merging subroutine involves (n/(2^(k-1))) sub-arrays of size (2^(k-1)),
+ * taking O(n) time.
+ *
+ * Since <interval> doubles at every iteration of the merge process, there are logn such levels. Every level takes
+ * O(n) time, hence overall time complexity is n * logn = O(nlogn)
+ *
+ * Regardless of how sorted the input array is, MergeSort carries out the partitioning and merging process, so the
+ * time complexity of MergeSort is O(nlogn) for all cases.
+ *
+ * Space:
+ * - O(n) since we require a temporary array to temporarily store the merged elements in sorted order
+ */
+
 public class MergeSort {
+
+    /**
+     * Sorts the given array in non-decreasing order.
+     *
+     * @param arr The given array to be sorted.
+     */
+    public static void sort(int[] arr) {
+        int interval = 1;
+        int n = arr.length;
+        int[] temp = new int[n];
+
+        while (interval < n) {
+            for (int i = 0; i < n - interval; i += 2 * interval) {
+                int end = Math.min(i + 2 * interval - 1, n - 1);
+                int mid = i + interval - 1;
+                merge(arr, i, mid, end, temp);
+            }
+            interval *= 2;
+        }
+    }
+
+    /**
+     * Merges two sorted sub-arrays within the given array. The two sub-arrays are arr[start, mid] and
+     * arr[mid + 1, end]. Upon completion of this function, arr[start, end] will be in sorted order.
+     *
+     * @param arr The array containing the sub-arrays to be merged.
+     * @param start The starting index of the first sub-array to be merged.
+     * @param mid The ending index (inclusive) of the first sub-array to be merged. In the iterative implementation,
+     *            the mid parameter is required in the merge function to determine the splitting point between the
+     *            sub-arrays to be merged.
+     * @param end The ending index (inclusive) of the second sub-array to be merged.
+     * @param temp A temporary array used for merging intermediate results.
+     */
+    private static void merge(int[] arr, int start, int mid, int end, int[] temp) {
+        int i = start;
+        int j = mid + 1;
+        int pointer = start;
+
+        // Merge the two sorted sub-arrays into the temp array
+        while (i <= mid && j <= end) {
+            if (arr[i] <= arr[j]) {
+                //we use <= here to maintain stability of MergeSort. If arr[i] == arr[j], the algorithm prefers the
+                //one from the left sub-array (arr[i]). This decision preserves the relative order of equal elements.
+
+                //if we change this to arr[i] >= arr[j], we can sort the array in non-increasing order.
+
+                temp[pointer] = arr[i];
+                i++;
+            } else {
+                temp[pointer] = arr[j];
+                j++;
+            }
+            pointer++;
+        }
+
+        // Copy any remaining elements from the left sub-array
+        while (i <= mid) {
+            temp[pointer] = arr[i];
+            i++;
+            pointer++;
+        }
+
+        // Copy any remaining elements from the right sub-array
+        while (j <= end) {
+            temp[pointer] = arr[j];
+            j++;
+            pointer++;
+        }
+
+        // Copy the merged elements back to the original array
+        for (int k = start; k <= end; k++) {
+            arr[k] = temp[k];
+        }
+    }
+
 }

src/algorithms/sorting/mergeSort/recursive/MergeSort.java

@@ -1,11 +1,12 @@
 package src.algorithms.sorting.mergeSort.recursive;
 
 /** Here, we are implementing MergeSort where we sort the array in increasing (or more precisely, non-decreasing)
- * order.
+ * order recursively.
  *
  * Brief Description:
- * MergeSort is a divide-and-conquer sorting algorithm that sorts an array by recursively dividing it into two halves,
- * sorting each half separately, and then merging the sorted halves to produce the final sorted output.
+ * MergeSort is a divide-and-conquer sorting algorithm. The recursive implementation takes a top-down approach by
+ * recursively dividing the array into two halves, sorting each half separately, and then merging the sorted halves
+ * to produce the final sorted output.
  *
  * Implementation Invariant (for the merging subroutine):
  * The sub-array temp[start, (k-1)] consists of the (𝑘−start) smallest elements of arr[start, mid] and
@@ -31,7 +32,7 @@
 public class MergeSort {
 
     /**
-     * Sorts the sub-array arr[start, end] using the Merge Sort algorithm.
+     * Sorts the sub-array arr[start, end] using the MergeSort algorithm.
      *
      * @param arr The given array to be sorted.
      * @param start The starting index of the sub-array to be sorted.
@@ -49,13 +50,12 @@ private static void mergeSort(int[] arr, int start, int end, int[] temp) {
     }
 
     /**
-     * Merges two sorted sub-arrays within the given array using the Merge Sort algorithm. The two sub-arrays are
-     * arr[start, mid] and arr[mid + 1, end]. Upon completion of this function, arr[start, end] will be in sorted
-     * order.
+     * Merges two sorted sub-arrays within the given array. The two sub-arrays are arr[start, mid] and
+     * arr[mid + 1, end]. Upon completion of this function, arr[start, end] will be in sorted order.
      *
      * @param arr The array containing the sub-arrays to be merged.
      * @param start The starting index of the first sub-array to be merged.
-     * @param end The ending index of the second sub-array to be merged.
+     * @param end The ending index (inclusive) of the second sub-array to be merged.
      * @param temp A temporary array used for merging intermediate results.
      */
     private static void merge(int[] arr, int start, int end, int[] temp) {
@@ -104,7 +104,7 @@ private static void merge(int[] arr, int start, int end, int[] temp) {
     /**
      * Sorts the given array in non-decreasing order.
      *
-     * @param arr array to be sorted
+     * @param arr The given array to be sorted
      */
     public static void sort(int[] arr) {
         int n = arr.length;

test/algorithms/mergeSort/iterative/MergeSortTest.java

@@ -0,0 +1,49 @@
+package test.algorithms.mergeSort.iterative;
+
+import org.junit.Test;
+
+import src.algorithms.sorting.mergeSort.iterative.MergeSort;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class MergeSortTest {
+
+    @Test
+    public void test_insertionSort_shouldReturnSortedArray() {
+        int[] firstArray =
+                new int[] {2, 3, 4, 1, 2, 5, 6, 7, 10, 15, 20, 13, 15, 1, 2, 15, 12, 20, 21, 120, 11, 5, 7, 85, 30};
+        int[] firstResult = Arrays.copyOf(firstArray, firstArray.length);
+        MergeSort.sort(firstResult);
+
+        int[] secondArray
+                = new int[] {9, 1, 2, 8, 7, 3, 4, 6, 5, 5, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        int[] secondResult = Arrays.copyOf(secondArray, secondArray.length);
+        MergeSort.sort(secondResult);
+
+        int[] thirdArray = new int[] {};
+        int[] thirdResult = Arrays.copyOf(thirdArray, thirdArray.length);
+        MergeSort.sort(thirdResult);
+
+        int[] fourthArray = new int[] {1};
+        int[] fourthResult = Arrays.copyOf(fourthArray, fourthArray.length);
+        MergeSort.sort(fourthResult);
+
+        int[] fifthArray = new int[] {5,1,1,2,0,0};
+        int[] fifthResult = Arrays.copyOf(fifthArray, fifthArray.length);
+        MergeSort.sort(fifthResult);
+
+        Arrays.sort(firstArray);  // get expected result
+        Arrays.sort(secondArray); // get expected result
+        Arrays.sort(thirdArray);  // get expected result
+        Arrays.sort(fourthArray);  // get expected result
+        Arrays.sort(fifthArray);  // get expected result
+
+        assertArrayEquals(firstResult, firstArray);
+        assertArrayEquals(secondResult, secondArray);
+        assertArrayEquals(thirdResult, thirdArray);
+        assertArrayEquals(fourthResult, fourthArray);
+        assertArrayEquals(fifthResult, fifthArray);
+    }
+}