Create four methods named insertionSort(), bubblesort(), mergesort() and quicksort(). Implement the sorting algorithms in the corresponding methods. In the main method, create four arrays a, b, c, d and initialize them with the same values. Pass these four arrays in four different functions. Create four instance variables named insertionSwap, bubbleSwap, countMerge, and countQuickSort and initialize them to 0. In methods insertionSort(), bubblesort() and quicksort(), increment the variables insertionSwap, bubbleSwap, and countQuickSort respectively by one whenever they call the method swap(). In method mergesort(), increment the variable countMerge by one to count the swaps. Use method swap() to swap the values.

Step 1

The JAVA program uses four different methods named insertionSort(), bubblesort(), mergesort() and quicksort() to implement four different algorithms identical to the name of each method to sort four identical integer arrays then print the number of swaps made by each algorithm to sort the array.

Approach: -  

Creating the main class and declaring four instance variables insertionSwap, bubbleSwap, countMerge, and countQuickSort and initializing them with zero. These variables are used to store the number of swaps made in each technique to sort the array.

Defining the main method, and creating four integer arrays a[], b[], c[] and d[] and initializing them with same integer values.

Inside the main() calling the four methods insertionSort(), bubblesort(), mergesort() and quicksort(). These methods are defined outside the main method.

Defining the methods insertionSort(), bubblesort(), mergesort() and quicksort() one by one using the four instance variables insertionSwap, bubbleSwap, countMerge, and countQuickSort to count the number of swaps made in each technique to sort the four identical arrays.

In the above-defined method, four sorting algorithms are implemented identically to their names.

The swap() method is defined to swap the values.  

Step 2

Java Program: -

//main class

public class Main

{

   //declaring the four instance variables

   static int insertionSwap = 0;       //initializing with zero

   static int bubbleSwap = 0;          //initializing with zero

   static int countMerge=0;            //initializing with zero

   static int countQuickSort=0;        //initializing with zero

//main method

public static void main(String[] args)

{

   //declaring the four arrays

   //initializing them with same values

   //array a[]

   int[] a = {2,34,56,21,46,31,77,28,67,68,22,81,91,61,89,33,44,99,18,109};

   //array b[]

   int[] b = {2,34,56,21,46,31,77,28,67,68,22,81,91,61,89,33,44,99,18,109};

   //array c[]

   int[] c = {2,34,56,21,46,31,77,28,67,68,22,81,91,61,89,33,44,99,18,109};

   //array d[]

   int[] d = {2,34,56,21,46,31,77,28,67,68,22,81,91,61,89,33,44,99,18,109};

   //calling the functions in the main method

   //passing a as the parameter

   insertionSort(a);

   //passing b as the parameter

   bubbleSort(b);

   //passing c as the parameter

   mergeSort(c);

   //passing d as the parameter

   quickSort(d);

   //displaying the message

   //displaying the swap count made in insertionSort method

   System.out.println("Number of swaps in insertionSort is: "+insertionSwap);

   //displaying the swap count made in bubbleSort method

   System.out.println("Number of swaps in bubbleSort is: "+bubbleSwap);

   //displaying the swap count made in mergeSort method

   System.out.println("Number of swaps in mergeSort is: "+countMerge);

   //displaying the swap count made in quickSort method

   System.out.println("Number of swaps in quickSort is: "+countQuickSort);

}

//defining the method insertionSort and passing an integer array

public static int[] insertionSort(int[] ar)

{

   //first for-loop is used

   for (int p = 1; p < ar.length; p++)

   {

   //inserting the elements of array

   int val = ar[p];

   //declaring the variable

   int q;

   //second for loop

   for (q = p-1; q >= 0 && ar[q] > val; q--)

   {

       //incrementing the count    

       insertionSwap++;

       //swapping the values

       ar[q +1] = ar[q];

   }  

       //swapping the values

       ar[q +1] = val;

   }

   //return the array  

   return ar;

}

//defining the method bubbleSort and passing an integer array

public static int[] bubbleSort(int[] ar)

{

   //storing the length of array in the variable n

   int n = ar.length;

   //first for loop

   for (int p = 0; p < n-1; p++)

   //second for loop

   for (int q = 0; q < n-p-1; q++)

   //to check whether the element stored at index q is greater than the element at q+1

   if (ar[q] > ar[q+1])

   {

       //calling the swap function

       swap(ar,q,q+1);

       //incrementing the count

       bubbleSwap++;

   }

   //return the array

   return ar;

}

//defining the method bubbleSort and passing an integer array

public static int[] mergeSort(int[] ar)

{

   //return statement

   return mergeSort(ar, 0, ar.length-1);

}

//defining the method bubbleSort and passing an integer array and two integer variables

answerfc- file compare;

the answer to your question would be something called hertz. the unit of measurement called a hertz, which is one cycle per second, is used to measure clock speed. within one cycle, your computer processes, refreshes, or updates itself to the changes that it is going through. in the case of computer clock speed, one hertz equals one tick per second. the clock speed of computers is usually measured in megahertz (mhz) or gigahertz (ghz)