Using Java implementations presented in the algorithms below.Practice Mergesort algorithm with Comparable Java objects whose class definition implements Java's Comparable interface. For example, using sample Comparable Student objects or Comparable Java class objects of your own implementation. Algorithm:void mergesort(E[] A, E[] temp, int l, int r) { int i, j, k, mid = (l+r)/2; if (l == r) return; // List has one element if ((mid-l) >= THRESHOLD) mergesort(A, temp, l, mid); else inssort(A, l, mid-l+1); if ((r-mid) > THRESHOLD) mergesort(A, temp, mid+1, r); else inssort(A, mid+1, r-mid); // Do merge. First, copy 2 halves to temp. for (i=l; i<=mid; i++) temp[i] = A[i]; for (j=1; j<=r-mid; j++) temp[r-j+1] = A[j+mid]; // Merge sublists back to array for (i=l,j=r,k=l; k<=r; k++) if (temp[i].compareTo(temp[j])<0) A[k] = temp[i++]; else A[k] = temp[j--];} Page <202>of 344ZOOM+MergesortList mergesort(List inlist) {if (inlist.length() <= 1) return inlist;List 11 = half of the items from inlist;List 12= other half of items from inlist;return merge (mergesort(11),mergesort(12));}36 20 17 13 28 14 23 1520 36 13 17|14 28||15 2313 17 20 36|| 14 15 23 2813 14 15 17 20 23 28 36 Page <203of 344ZOOM+Mergesort Implementationstatic >void mergesort(E[] A, E[] temp, int l, int r) {int mid = (1+r)/2;if (1 =mergesort(A, temp, l, mid);mergesort (A, temp, mid+1, r);for (int i=i; i<=r; i++)' // Copy subarraytemp[i] = A[i];// Do the merge operation back to Aint ilr) return;1; int i2 = mid + 1;for (int curr=l; curr<=r; curr++) {if (ilA[curr] =else if (i2 > r) ¯// Right sublist exhaustedA[curr] = temp[il++] ;else if (temp[il].compareTo (temp[i2])<0)A[curr] = temp[il++];else A[curr] = temp[i2++] ;}}mid+1) // Left sublist exhaustedtemp[i2++] ;

The current task here is to write the java program to do the merge sorting using comparable interface. comparable interface in java: The client class's objects are sorted using the Java Comparable interface. This interface is part of the java.lang package and only has one method, compareTo (Object). It only has an unique sorting sequence, which means you could only sort the items by a single data member. Merge sort: Merge sorting is one of the most efficient techniques for sorting data. It functions on the divide-and-conquer principle. Merge sort repeatedly divides a list into sub lists until each sub lists has only one entry, then merges the sub lists into a sorted list. The primary concept behind merge sort is as follows. Divide the unsorted list into two sublists of about half the size Sort each of the two sublists Merge the two sorted sublists back into one sorted list Program implementation: import java.util.*; import java.lang.*;public class MergerSort { public static void main(String[] args) { //Unsorted array Integer[] a = {36,20,17,13,28,14,23,15 };//Call merge sort mergeSort(a);//Check the output which is sorted array System.out.println(Arrays.toString(a));}public static Comparable[] mergeSort(Comparable[] list) { //If list is empty; no need to do anythingif (list.length <= 1) { return list;} //Split the array in half in two partsComparable[] first = new Comparable[list.length / 2];Comparable[] second = new Comparable[list.length - first.length];System.arraycopy(list, 0, first, 0, first.length);System.arraycopy(list, first.length, second, 0, second.length);//Sort each half recursively mergeSort(first);mergeSort(second);//Merge both halves together, overwriting to original arraymerge(first, second, list); return list; }private static void merge(Comparable[] first, Comparable[] second, Comparable[] result) {//Index Position in first array - starting with first elementint iFirst = 0; //Index Position in second array - starting with first element int iSecond = 0;//Index Position in merged array - starting with first positionint iMerged = 0;//Compare elements at iFirst and iSecond and move smaller element at iMerged while (iFirst < first.length && iSecond < second.length) {if (first[iFirst].compareTo(second[iSecond]) < 0) {result[iMerged] = first[iFirst]; iFirst++; } else{result[iMerged] = second[iSecond]; iSecond++;}iMerged++; }//copy remaining elements from both halves - each half will have already sorted elementsSystem.arraycopy(first, iFirst, result, iMerged, first.length - iFirst); System.arraycopy(second, iSecond, result, iMerged, second.length - iSecond);}} Diagram for better understanding: output: Input array: [36,20,17,13,28,14,23,15 ] output array: [13,14,15,17,20,23,28,36]