Question

In the most basic/easiest JAVA please change the following code into RECURISON make sure the program complies correctly. (It is currently in iterative.) please show comments how they are different after.

//public class

public class MergeSort

{

public static void mergeSort(int[] array)

{

int start;

int i;

int minScan;

int minValue;

int counter = 0;

/**

The outer loop iterates once for each element in the

array. The start variable marks the position where the scan should begin.

**/

for(start = 0; start < array.length-1; start++)

{

//assume the first element in the scannable area is the smallest value.

minScan = start;

minValue = array[start];

/**

Scan the array, starting at the 2nd element in

the scannable area. We are looking for the smallest value in

the scannable area.

**/

for(i = start+1;i < array.length;i++)

{

if(array[i] < minValue)

{

minValue = array[i];

minScan = i;

counter++;

}

}

//swap the element with the smallest value with the first element in the scannable area.

array[minScan] = array [start];

array[start] = minValue;

}

System.out.print("\nSwaps:" + counter); //displays swaps.

}

}

Answer 1

MergeSort.java

import java.util.Scanner;

public class MergeSort
{
   public static void main(String args[])
   {
       Scanner sc = new Scanner(System.in);

       System.out.print("Enter the size of unsorted array: ");
       int n = sc.nextInt();

       int[] list = new int[n];

       for (int i = 0; i < n; i++)
       {
           System.out.printf("Enter %d element: ", i+1);
           list[i] = sc.nextInt();
       }

       System.out.println("\n-----------------------------------------\n");
       System.out.println("List before sorting: ");
      
       for (int i = 0; i < list.length; i++)
           System.out.print(list[i] + " ");

       mergeSort(list, 0, list.length - 1);

       System.out.println("\n-----------------------------------------\n");
      
       System.out.print("List after sorting: ");
       for (int i = 0; i < list.length; i++)
           System.out.print(list[i] + " ");

       sc.close();           // closing scanner is important
   }

   public static void mergeSort(int list[], int low, int high)
   {
       if (low >= high)
           return;

       int middle = (low + high) / 2;

       mergeSort(list, low, middle);
       mergeSort(list, middle + 1, high);
       merge(list, low, middle, high);
   }

   private static void merge(int list[], int low, int middle, int high)
   {

       int endIst = middle;

       int endIInd = middle + 1;

       int l = low;

       while ((l <= endIst) && (endIInd <= high))
       {
           if (list[low] < list[endIInd])
               low++;
           else
           {
               int temp = list[endIInd];
               for (int j = endIInd - 1; j >= low; j--)
                   list[j + 1] = list[j];

               list[low] = temp;
               low++;

               endIst++;
               endIInd++;
           }
       }
   }

}

Output:

Answer 2

CODE:

public class MergeSort
{
//initialise counter variable to 0
static int counter=0;
  
public static void main(String args[] ) throws Exception {
  
//initialise new array
int[] intArray = new int[]{ 10,2,5,4,5,6,7,8,9,11 };
  
//call mergesort function
mergeSort(intArray, intArray.length, 0);
  
//displays swaps.
System.out.print("\nSwaps:" + counter);

}
  
  
static int minIndex(int a[], int i, int j)
{
//if starting ndex and size of the array are same
if (i == j)
return i;

// find minimum of remaining elements using recursion
int k = minIndex(a, i + 1, j);

// Return minimum of current and remaining.
return (a[i] < a[k])? i : k;
}

  
public static void mergeSort(int array[], int n, int position)
{

// Return when starting and size are same
if (position == n)
return;

// calling minimum index function for minimum index
int min = minIndex(array, position, n-1);

// Swapping when index nd minimum index are not same
if (min != position){
// swap
int temp = array[min];
array[min] = array[position];
array[position] = temp;
counter++;
}
// Recursively calling mergeSort function
mergeSort(array, n, position + 1);
}

}

OUTPUT: