Added mergesort recursive int implementation

Author: kaitinghh

out/production/src/src/algorithms/sorting/insertionSort/README.md

@@ -0,0 +1,3 @@
+![InsertionSort](../../../../assets/InsertionSort.png)
+
+Image taken from: https://www.hackerrank.com/challenges/correctness-invariant/problem

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

@@ -1,91 +1,4 @@
 package src.algorithms.sorting.mergeSort.iterative;
 
-import java.util.*;
-
-/**
- * Iterative implementation of Merge sort with O(n) space
- */
 public class MergeSort {
-
-  /**
-   * Sorts a list from a specified start to end point.
-   *
-   * Note: starting with an interval size (call this var <interval>) of 1 and iteratively *2,
-   * Merge two sub-lists of size <interval> together using merge routine.
-   * Invariant: Partitioning the main list into sub-lists of size <interval>,
-   * each of this sub-list is sorted within itself (the last sub-list may not be of
-   * size <interval> but it is still sorted since the size is necessarily less than <interval>.
-   *
-   * @param <T> generic type of object
-   * @param lst list of objects to be sorted
-   * @param start sorting starts at this index
-   * @param end sorting ends (inclusive) at this index
-   */
-  private static <T extends Comparable<T>> void mergeSort(List<T> lst, int start, int end) {
-    if (start == end) {
-      return;
-    }
-    int size = lst.size();
-    int interval = 1;
-    List<T> tmp = new ArrayList<>();
-    for (T item : lst) {
-      tmp.add(item);
-    }
-    while (interval < lst.size()) {
-      for (int i = 0; i + interval < size; i += 2*interval) {
-        int start1 = i;
-        int start2 = i + interval;
-        int e = i + 2 * interval - 1;
-        if (e > size - 1) {
-          e = size - 1;
-        }
-        merge(lst, tmp, start1, start2, e);
-      }
-      interval *= 2;
-    }
-    
-  }
-
-  /**
-   * Merging algorithm that merges two sorted sub-lists into one final sorted list.
-   * @param <T> generic type of object
-   * @param lst at the end, elements from s1 to e (inclusive) of lst are sorted
-   * @param s1 start index of first sub-list
-   * @param s2 start index of second sub-list; note that end index of first sub-list is s2-1
-   * @param e end index of second sub-list
-   */
-  private static <T extends Comparable<T>> void merge(List<T> lst, List<T> tmp, int s1, int s2, int e) {
-    int startLeft = s1;
-    int startRight = s2;
-    int tmpIdx = s1;
-    while (startLeft < s2 && startRight < e + 1) {
-      if (lst.get(startLeft).compareTo(lst.get(startRight)) < 0) {
-        tmp.set(tmpIdx, lst.get(startLeft++));
-      } else {
-        tmp.set(tmpIdx, lst.get(startRight++));
-      }
-      tmpIdx++;
-    }
-
-    while (startLeft < s2) {
-      tmp.set(tmpIdx++, lst.get(startLeft++));
-    }
-
-    while (startRight < e + 1) {
-      tmp.set(tmpIdx++, lst.get(startRight++));
-    }
-
-    for (int i = s1; i < e+1; i++) {
-      lst.set(i, tmp.get(i));
-    }
-  }
-
-  /**
-   * Sorting algorithm that clients calls
-   * @param <T> generic type
-   * @param lst list to be sorted
-   */
-  public static <T extends Comparable<T>> void sort(List<T> lst) {
-    mergeSort(lst, 0, lst.size() - 1);
-  }
 }

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

@@ -0,0 +1,91 @@
+package src.algorithms.sorting.mergeSort.legacy.iterative;
+
+import java.util.*;
+
+/**
+ * Iterative implementation of Merge sort with O(n) space
+ */
+public class MergeSort {
+
+  /**
+   * Sorts a list from a specified start to end point.
+   *
+   * Note: starting with an interval size (call this var <interval>) of 1 and iteratively *2,
+   * Merge two sub-lists of size <interval> together using merge routine.
+   * Invariant: Partitioning the main list into sub-lists of size <interval>,
+   * each of this sub-list is sorted within itself (the last sub-list may not be of
+   * size <interval> but it is still sorted since the size is necessarily less than <interval>.
+   *
+   * @param <T> generic type of object
+   * @param lst list of objects to be sorted
+   * @param start sorting starts at this index
+   * @param end sorting ends (inclusive) at this index
+   */
+  private static <T extends Comparable<T>> void mergeSort(List<T> lst, int start, int end) {
+    if (start == end) {
+      return;
+    }
+    int size = lst.size();
+    int interval = 1;
+    List<T> tmp = new ArrayList<>();
+    for (T item : lst) {
+      tmp.add(item);
+    }
+    while (interval < lst.size()) {
+      for (int i = 0; i + interval < size; i += 2*interval) {
+        int start1 = i;
+        int start2 = i + interval;
+        int e = i + 2 * interval - 1;
+        if (e > size - 1) {
+          e = size - 1;
+        }
+        merge(lst, tmp, start1, start2, e);
+      }
+      interval *= 2;
+    }
+    
+  }
+
+  /**
+   * Merging algorithm that merges two sorted sub-lists into one final sorted list.
+   * @param <T> generic type of object
+   * @param lst at the end, elements from s1 to e (inclusive) of lst are sorted
+   * @param s1 start index of first sub-list
+   * @param s2 start index of second sub-list; note that end index of first sub-list is s2-1
+   * @param e end index of second sub-list
+   */
+  private static <T extends Comparable<T>> void merge(List<T> lst, List<T> tmp, int s1, int s2, int e) {
+    int startLeft = s1;
+    int startRight = s2;
+    int tmpIdx = s1;
+    while (startLeft < s2 && startRight < e + 1) {
+      if (lst.get(startLeft).compareTo(lst.get(startRight)) < 0) {
+        tmp.set(tmpIdx, lst.get(startLeft++));
+      } else {
+        tmp.set(tmpIdx, lst.get(startRight++));
+      }
+      tmpIdx++;
+    }
+
+    while (startLeft < s2) {
+      tmp.set(tmpIdx++, lst.get(startLeft++));
+    }
+
+    while (startRight < e + 1) {
+      tmp.set(tmpIdx++, lst.get(startRight++));
+    }
+
+    for (int i = s1; i < e+1; i++) {
+      lst.set(i, tmp.get(i));
+    }
+  }
+
+  /**
+   * Sorting algorithm that clients calls
+   * @param <T> generic type
+   * @param lst list to be sorted
+   */
+  public static <T extends Comparable<T>> void sort(List<T> lst) {
+    mergeSort(lst, 0, lst.size() - 1);
+  }
+}

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

@@ -0,0 +1,73 @@
+package src.algorithms.sorting.mergeSort.legacy.recursive;
+
+import java.util.*;
+
+/**
+ * Recursive implementation of merge sort (in ascending order) 
+ * with only additional O(n) space required.
+ */
+public class MergeSort {
+
+  /**
+   * Sorts a list from a specified start to end point, making use of 
+   * and additional copy list to store sorted elements.
+   * @param <T> generic type of object
+   * @param lst list of objects to be sorted from start to end 
+   * @param start sorting of elements starting from this index
+   * @param end sorting of elements up till and inclusive of this index
+   * @param copy copy of the list to store and extract elements in sorted position
+   */
+  private static <T extends Comparable<T>> void mergeSort(List<T> lst, int start, int end, List<T> copy) {
+    if (start == end) {
+      return;
+    }
+    int mid = start + (end - start) / 2;
+    mergeSort(copy, start, mid, lst);
+    mergeSort(copy, mid + 1, end, lst);
+    merge(lst, start, mid, end, copy);
+  }
+
+  /**
+   * Merging algorithm that merges two sorted sub-lists into one final sorted list.
+   * @param <T> generic type of object
+   * @param arr at the end, elements from s to e (inclusive) of arr are sorted
+   * @param s start of first sub-list
+   * @param m end (inclusive) of first sub-list; note start of second sub-list is m+1
+   * @param e end (inclusive) of second sub-list 
+   * @param cpy copy of the sorted sub-lists to extract and insert sorted final list into arr
+   */
+  private static <T extends Comparable<T>> void merge(List<T> arr, int s, int m, int e, List<T> cpy) {
+    int start = s;
+    int startLeft = s;
+    int startRight = m + 1;
+
+    while (startLeft < m + 1 && startRight < e + 1) {
+      if (cpy.get(startLeft).compareTo(cpy.get(startRight)) < 0) {
+        arr.set(start++, cpy.get(startLeft++));
+      } else {
+        arr.set(start++, cpy.get(startRight++));
+      }
+    }
+
+    while (startLeft < m + 1) {
+      arr.set(start++, cpy.get(startLeft++));
+    }
+
+    while (startRight < e + 1) {
+      arr.set(start++, cpy.get(startRight++));
+    }
+  }
+
+  /**
+   * Sorting algorithm to be called by client.
+   * @param <T> generic type
+   * @param lst list of elements to be sorted.
+   */
+  public static <T extends Comparable<T>> void sort(List<T> lst) {
+    List<T> copy = new ArrayList<>();
+    for (int i = 0; i < lst.size(); i++) {
+      copy.add(lst.get(i));
+    }
+    mergeSort(lst, 0, lst.size() - 1, copy);
+  }
+}