Add support for using merge sort on generic objects implementing the Comparable interface.

Author: Wyvernix

src/main/java/com/abranhe/allalgorithms/sorting/MergeSort.java

@@ -23,11 +23,14 @@
 
 package com.abranhe.allalgorithms.sorting;
 
+import java.util.Arrays;
+
 /**
  * The class {@code MergeSort} contains methods for performing
  * a poor :( merge sort algorithm of Integers and Doubles
  *
  * @author  Carlos Abraham Hernandez
+ * @author  Brandon Gastelo
  * @since   0.0.1
  */
 public class MergeSort {
@@ -138,6 +141,51 @@ private static void merge(double arr[], int l, int m, int r) {
             k++;
         }
     }
+    
+    /**
+     * Merges two subarrays of arr[]. generic type
+     * First subarray is arr[l..m]
+     * Second subarray is arr[m+1..r]
+     *
+     * @param arr array
+     * @param l index to start sorting
+     * @param m index of the middle of the array
+     * @param r index to finish sorting
+     */
+    private static <T extends Comparable<? super T>> void merge(T arr[], int l, int m, int r) {
+    	int n1 = m - l + 1;
+        int n2 = r - m;
+
+        T L[] = Arrays.copyOfRange(arr, l, l+n1);
+        T R[] = Arrays.copyOfRange(arr, m+1, r+1);
+
+        int i = 0, j = 0;
+
+        int k = l;
+        while (i < n1 && j < n2) {
+            if (L[i].compareTo(R[j]) <= 0) {
+                arr[k] = L[i];
+                i++;
+            }
+            else {
+                arr[k] = R[j];
+                j++;
+            }
+            k++;
+        }
+
+        while (i < n1) {
+            arr[k] = L[i];
+            i++;
+            k++;
+        }
+
+        while (j < n2) {
+            arr[k] = R[j];
+            j++;
+            k++;
+        }
+    }
 
     /**
      * Sort array of integers
@@ -174,7 +222,24 @@ private static void sort(double arr[], int l, int r) {
             merge(arr, l, m, r);
         }
     }
+    
+    /**
+     * Sort array of generic objects
+     * @param arr array
+     * @param l index to start sorting
+     * @param r index to finish sorting
+     */
+    private static <T extends Comparable<? super T>> void sort(T[] arr, int l, int r) {
+    	if (l < r) {
+            int m = (l+r)/2;
+
+            sort(arr, l, m);
+            sort(arr , m+1, r);
 
+            merge(arr, l, m, r); 
+    	}
+    }
+    
     /**
      * The sort method of the {@code MergeSort} class
      * takes an array of {@code Integers} an sort it.
@@ -198,4 +263,17 @@ public static void sort(double arr[]) {
         int r = arr.length-1;
         sort(arr, l, r);
     }
+    
+    /**
+     * The sort method of the {@code MergeSort} class
+     * takes an array of {@code Comparable} objects
+     * and sorts them.
+     *
+     * @param arr array of objects to be sorted
+     */
+    public static <T extends Comparable<? super T>> void sort(T arr[]) {
+    	int l = 0;
+    	int r = arr.length-1;
+    	sort(arr, l, r);
+    }
 }