Question

MERGE SORTING!!! JAVAAAA

- Implement the non-recursive version of MergeSort. Also separately, implement the small-size cutoff optimization, with InsertionSort as the small-size sort. (So there should be a regular Merge Sort and an optimized Merge Sort).

- All implementations should be in the function.

public void mergeSorting (int [] data){

}

- Implement the main method with (at least) the following tests:

• Create tests to make sure the merge works.
• Test the sort with 10 elements to see if the result is sorted and that no elements were overwritten or "lost" in the sorting.
• The same with 100 elements
• Recall that String's implement the Comparable interface and that anything that implements that interface can be compared using the compareTo method (in terms of strings)

Answer 1

Regular Merge sort implementation(non-recursive):

import java.util.Arrays;
import java.util.Random;

class Main
{
   // Driver function to Merge two sorted sub-arrays
   public static void merge(int[] arr, int[] temp, int from, int mid, int to)
   {
       int k = from, i = from, j = mid + 1;

      
       while (i <= mid && j <= to) {
           if (arr[i] < arr[j]) {
               temp[k++] = arr[i++];
           } else {
               temp[k++] = arr[j++];
           }
       }

      
       while (i < arr.length && i <= mid) {
           temp[k++] = arr[i++];
       }

      
       for (i = from; i <= to; i++) {
           arr[i] = temp[i];
       }
   }

   // This function iteratively sort array A[low..high] using temporary array
   public static void mergeSorting(int[] arr)
   {
       int low = 0;
       int high = arr.length - 1;

       // sort array A[] using temporary array temp
       int[] temp = Arrays.copyOf(arr, arr.length);

      
       for (int m = 1; m <= high - low; m = 2*m)
       {
          
           for (int i = low; i < high; i += 2*m)
           {
               int from = i;
               int mid = i + m - 1;
               int to = Integer.min(i + 2 * m - 1, high);

               merge(arr, temp, from, mid, to);
           }
       }
   }

   // Main function for testing
   // Please change the size of array based on number of element you want
   public static void main(String[] args)
   {
   Random rd = new Random(); // creating Random object
int[] arr = new int[10];
for (int i = 0; i < arr.length; i++) {
arr[i] = rd.nextInt(1000);
}

       System.out.println("Original Array : " + Arrays.toString(arr));
       mergeSorting(arr);
       System.out.println("Sorted Array : " + Arrays.toString(arr));
   }
}

Optimized merge sort implementation:

import java.util.Arrays;
import java.util.Random;

public class Main {
  
private static final int Cutoff = 5;

private static int numberOfRows;
private static int row = 0;

// stably merge a[lo .. mid] with a[mid+1 .. hi] using aux[lo .. hi]
public static void merge(int[] a, int[] aux, int lo, int mid, int hi) {

  
for (int k = lo; k <= hi; k++) {
aux[k] = a[k];
}

int i = lo, 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 (less(aux[j], aux[i])) a[k] = aux[j++];
else a[k] = aux[i++];
}
}

// mergesort a[lo..hi] using auxiliary array aux[lo..hi]
private static void sort(int[] a, int[] aux, int lo, int hi) {
int n = hi - lo + 1;
if (n <= Cutoff) {
insertionSort(a, lo, hi);

return;
}
if (hi <= lo) return;
int mid = lo + (hi - lo) / 2;
sort(a, aux, lo, mid);
sort(a, aux, mid + 1, hi);
merge(a, aux, lo, mid, hi);
  
}

public static void mergeSorting(int[] a) {
int[] aux = new int[a.length];
sort(a, aux, 0, a.length-1);
}

// sort from a[lo] to a[hi] using insertion sort
private static void insertionSort(int[] a, int lo, int hi) {
for (int i = lo; i <= hi; i++)
for (int j = i; j > lo && less(a[j], a[j-1]); j--)
exchange(a, j, j-1);
}

private static boolean less(int v, int w) {
return v < w;
}

private static void exchange(int[] a, int i, int j) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}

// draw one row of trace
  
// Main function for testing
   // Please change the size of array based on number of element you want
public static void main(String[] args)
   {
   Random rd = new Random(); // creating Random object
int[] arr = new int[100];
for (int i = 0; i < arr.length; i++) {
arr[i] = rd.nextInt(1000);
}

       System.out.println("Original Array : " + Arrays.toString(arr));
       mergeSorting(arr);
       System.out.println("Modified Array : " + Arrays.toString(arr));
   }
}

Note: for testing please change the length of the array in the main function according to the requirement.