Question

Design a program that allows you to experiment with different sort algorithms in Java. This program should allow

you to easily plug-in new sort algorithms and compare them. Assume that input data is generated randomly and stored in

a text file (have no less than 2000 items to sort). Do not restrict your program to only one data type, or to one ordering relationship.

The data type, ordering relationship, and the sorting method must be input parameters for your program.

It must produce a comparison chart of all implemented sort algorithms (consider both comparisons and exchanges)

(So must show how many times its compared an exchanged (swapped).

. Start with insertion, selection and bubble sorts (other sorts will be included later.

This is for Data and Algorithm. Plese, help I will upvote. I promise!

                                              Please include this

1. Submit a design sheet presenting the overall structure of your program
2. pseudo-code descriptions of implemented sort algorithms,
3. extended explanation of all of the results that your program generates, the code, and all outputs. HEre is an example of how all of them should look. I have a bubble sort which counts the comparison and exchange.

   public class BubbleSortingMain {

      public static void main(String[] args) {
          int array1[] = {1,2,3,4,5,6,7,8,9,10}; // best case
          int array2[]= {10,9,8,7,6,5,4,3,2,1};//worst case
          bubbleSort(array1);
          bubbleSort(array2);
      }

   public static void bubbleSort(int[] array) {
      int numberOfItems = array.length;
   int comp=0,exch=0,temp=0;
   boolean cont = true;
      for (int pass=1; pass != numberOfItems; pass++)   {
   if (cont) {
   cont = false;
   for (int index=0; index != numberOfItems-pass; index++) {
                                  comp++;
          if (array[index]> array[index+1]) {
              exch++;
                   temp = array[index];
          array[index] = array[index+1];
          array[index+1] = temp;
   cont = true;
          }
      }
   }
   else
   break; // end outer if
   }  
      System.out.println ("comparsion: " + comp); // end inner if
      System.out.println ("exchange: " + exch); // end inner for
   }

   }
   

Answer 1

pseudocode in code comments :

public class Sorting {

    public static void main(String[] args) {
        int array1[] = {1,2,3,4,5,6,7,8,9,10}; // best case
        int array2[]= {10,9,8,7,6,5,4,3,2,1};//worst case
        bubbleSort(array1);
        bubbleSort(array2);
        int array3[] = {1,2,3,4,5,6,7,8,9,10}; // best case
        int array4[]= {10,9,8,7,6,5,4,3,2,1};//worst case
        selectionSort(array3);
        selectionSort(array4);
        int array5[] = {1,2,3,4,5,6,7,8,9,10}; // best case
        int array6[]= {10,9,8,7,6,5,4,3,2,1};//worst case
        insertionSort(array5);
        insertionSort(array6);
    }
    public static void printArrray(int[] array){
        int numberOfItems = array.length;
        for(int i=0;i<numberOfItems;i++){
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
    /*
     In insertion sort we make space for the current element in the array , and then insert the current element at that position
     ALGORITHM :
         1.Loop until pass = 1 to number of items
         2.let key be the current element
         3.For each element left to the current element , if it is greater than curr element , we exchange pass and index
         4.Thus at the end of loop we ll be left with a position suitable for key
         5.We insrt key into that position
     */
    public static void insertionSort(int[] array){
        System.out.println("********* INSERTION SORT ************");
        printArrray(array);
        int numberOfItems = array.length;
        int comp=0,exch=0;
        for (int pass = 1; pass < numberOfItems; ++pass) {
            int key = array[pass];
            int index = pass - 1;
            comp+=index;
            while (index >= 0 && array[index] > key) {
                exch++;
                array[index+1] = array[index];
                index = index - 1;
            }
            exch++;
            array[index+1] = key;
        }
        System.out.println ("comparsion: " + comp);
        System.out.println ("exchange: " + exch);
        printArrray(array);
        System.out.println();
    }
    /*
        In selection sort we select an element and find the minimum element on the right of that element
        and then exchange the element with the selected element.
        Hence at any stage of selection sort the left of selected element will always be sorted
        ALGORITHM :
            1.LOOP from (0 to length of array-1)
            2.let curr be the index current element
                store curr in temp variable minI
            3.loop from curr to the end of array to find minium number
                if(array[index]<array[minI]
                    minI = index
            4.After inner loop exchange elements at curr and minI
     */
    public static void selectionSort(int[] array){
        System.out.println("********** SELECTION SORT ***********");
        printArrray(array);
        int numberOfItems = array.length;
        int comp=0,exch=0;
        for (int pass=0; pass<numberOfItems-1; pass++)
        {
            int minI = pass;
            for (int index = pass+1; index < numberOfItems; index++) {
                comp++;
                if (array[index] < array[minI])
                    minI = index;
            }
            exch++;
            int temp = array[minI];
            array[minI] = array[pass];
            array[pass] = temp;
        }
        System.out.println ("comparsion: " + comp);
        System.out.println ("exchange: " + exch);
        printArrray(array);
        System.out.println();
    }
    public static void bubbleSort(int[] array) {
        System.out.println("********* BUBBLE SORT ***********");
        printArrray(array);
        int numberOfItems = array.length;
        int comp=0,exch=0,temp=0;
        boolean cont = true;
        for (int pass=1; pass != numberOfItems; pass++)   {
            if (cont) {
                cont = false;
                for (int index=0; index != numberOfItems-pass; index++) {
                    comp++;
                    if (array[index]> array[index+1]) {
                        exch++;
                        temp = array[index];
                        array[index] = array[index+1];
                        array[index+1] = temp;
                        cont = true;
                    }
                }
            }
            else
                break; // end outer if
        }
        System.out.println ("comparsion: " + comp); // end inner if
        System.out.println ("exchange: " + exch); // end inner for
        printArrray(array);
        System.out.println();
    }
}