Question

1. Create a program named MergeSort.java then copy the following code to your program:
   • public static void mergeSort(int[] arr){
        mergeSortRec(arr, 0, arr.length-1);
     }
     private static void mergeSortRec(int[] arr, int first, int last){
        if(first<last){
         int mid=(first+last)/2;
     mergeSortRec(arr, first, mid);
         mergeSortRec(arr, mid+1,last);
         merge(arr, first, mid, mid+1, last);
        }
     }
     private static void merge(int[] arr, int leftFirst,
        int leftLast, int rightFirst, int rightLast){
        int[] aux=new int[arr.length];
        //extra space, this is downside of this algorithm
        int index=leftFirst;
        int saveFirst=leftFirst;
        while(leftFirst<=leftLast && rightFirst <=rightLast){
     if(arr[leftFirst]<=arr[rightFirst]){
        aux[index++]=arr[leftFirst++];
         }else{
        aux[index++]=arr[rightFirst++];
         }
        }
        while(leftFirst<=leftLast){
         aux[index++]=arr[leftFirst++];
        }
        while(rightFirst<=rightLast)
         aux[index++]=arr[rightFirst++];
        for(index=saveFirst; index<=rightLast; index++)
         arr[index]=aux[index];
     }
2. Write a main method that accepts three numbers N, A, B (assume A<B) from the command argument list, then use the number N to create an N-element int array.
3. Assign random numbers between [A, B] to each of the N elements of the array.
4. Call mergeSort method to sort the array.
5. Write instructions to record the time spent on sorting.
6. (Optional) you may write code to verify the array was sorted successfully.
7. Once completed, test your program with different numbers N, A, B and screenshot your result. Your result should include the number of elements and sorting time.
8. Please include the following in the Word document you created for the assignment for the final submission:  
   • Copy/paste your completed code in MergeSort.java
   • Insert at least one screenshot of the running output in #7 above
   • Answer this question: What is the average Big O for this sort?

Answer 1

Complete code in java:-

import java.util.Random;
import java.util.Scanner;
import java.io.*;

class MergeSort {

// These are methods provided by you for sorting the input array
// Below method is driver method.
public static void mergeSort(int[] arr){
mergeSortRec(arr, 0, arr.length-1);
}

// This is the main function to sort the array.
private static void mergeSortRec(int[] arr, int first, int last){
if(first<last){

// Partition the array into two equal halves
int mid=(first+last)/2;

// Calling this function recurrsively for both the halves.
mergeSortRec(arr, first, mid);
mergeSortRec(arr, mid+1,last);

// Finally merging the two sorted halves.
merge(arr, first, mid, mid+1, last);
}
}

// This function will merge the 2 sorted halves and make a sorted array.
private static void merge(int[] arr, int leftFirst,
int leftLast, int rightFirst, int rightLast){
int[] aux=new int[arr.length];
//extra space, this is downside of this algorithm
int index=leftFirst;
int saveFirst=leftFirst;

// From here, this code is merging 2 sorted halves into one.
while(leftFirst<=leftLast && rightFirst <=rightLast){
if(arr[leftFirst]<=arr[rightFirst]){
aux[index++]=arr[leftFirst++];
}else{
aux[index++]=arr[rightFirst++];
}
}

while(leftFirst<=leftLast){
aux[index++]=arr[leftFirst++];
}

while(rightFirst<=rightLast)
aux[index++]=arr[rightFirst++];
for(index=saveFirst; index<=rightLast; index++)
arr[index]=aux[index];
}

// Main method
public static void main(String ... args) {

// Creating object for random number generation.
Random rand = new Random();

// Creating Scanner object for taking user input
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a = sc.nextInt();
int b = sc.nextInt();

// Creating array of size 'n'.
int arr[] = new int[n];

// Storing numbers into array in range 'a'-'b'
for(int i = 0; i < n; i++) {
arr[i] = rand.nextInt((b-a)+1)+a;
}

// Here we measuring time before starting mergeSort method.
long start = System.currentTimeMillis();
mergeSort(arr);

// Again measuring time before starting mergeSort method.
long end = System.currentTimeMillis();

// Priting desired output.
System.out.println("Time taken to sort "+n+ " numbers : " + (end - start) + "ms");
}
}

Screenshot of output:-

Mege sort uses divide and conquer technique, every time it divides array into 2 almost equal halves and merge this halves into one sorted subarray. Its average case time complexity is O(n*log(n)).