CMPS 144 Spring 2019
Prog. Assg. #4: Generic Partitioning and Recursive QuickSort
Due: 11:59pm, Monday, April 15

Summary

The task before you is to

1. Complete two classes that implement the java.util.Comparator interface and that define two different orderings on values of type String.

   Note: An ordering on a type is defined by a set of criteria by which it can be determined, for any pair of elements (x,y) of that type, which one of x<y, x=y, or x>y holds. Technically, to be an ordering, not only must exactly one of those expressions be true, but also it must be that x=y implies y=x (i.e., equality is symmetric) and that < is transitive (which is to say that if both x<y and y<z, then necessarily x<z.) End of note.

2. Modify a non-generic class whose instances can partition an array (or array segment) of Integer values to make it generic. The result will be a class such that, for any object/reference type T, and for any ordering that can be defined on type T, it is possible to create an instance of the new class that is capable of partitioning an array of type T[] in a manner consistent with that ordering.

3. Supply the body of a method that implements the classic recursive QuickSort algorithm.

The details follow.

Java Classes that you are given

• SelectionSorter: An instance of this (generic) class has sort() methods by which to sort an array (or segment thereof) containing values of any reference type. The constructor requires that a Comparator object be passed to it so that the resulting SelectionSorter object is capable of comparing the elements in whatever arrays it is later called upon to sort.

  You need not do anything with this class; it is made available to you for the purpose of providing a model when developing the PivotPartitioner and QuickSorter classes (see below).

• SorterTester: A Java application program that is for the purpose of testing either the SelectionSorter class described above or the QuickSorter method discussed below.
• IntegerComparator: This class implements the java.util.Comparator interface. An instance of this class is for the purpose of comparing values of type Integer. The application program described above makes use of it for the purpose of creating an instance of the SelectionSorter class capable of sorting arrays of type Integer[].
• PivotPartitionerInt: An instance of this (non-generic) class has partition() methods that can be used to partition an array (or segment thereof) of type Integer[] with respect to one of the values in the array, referred to as the resident pivot.

  Partitioning an array segment with respect to a resident pivot corresponds to doing Red/Blue partitioning in which values less than the pivot are classified as RED and values not less than the pivot are classified as BLUE. In addition, measures are taken to ensure that, in the end, the pivot element itself occupies the first location in the BLUE segment.

  This class is to serve as a model for developing the generic PivotPartitioner class (see below).

• PartitionerTester: A Java application for the purpose of testing instances of the PivotPartitioner class (see below).

Java classes you are to complete

• AlphabeticOrder and LenAlphaOrder: Each of these classes implements the java.util.Comparator interface. Its instances are for the purpose of defining two different orderings on values of type String. In one, the ordering is alphabetic. In the other, it is based first upon length and secondarily upon alphabetic ordering.

  Instances of these classes are used by the SorterTester and PartitionerTester applications listed above.

• PivotPartitioner: This is the generic version of the similarly named non-generic class listed above. Thus, it would make sense to begin with a copy of that class and to make the modifications necessary to "generic-ify" it. Use the SelectionSorter class as a model for how to incorporate generics.
• QuickSorter: An instance of this generic class has sort() methods for sorting an array or a segment thereof. In this respect it is similar to the SelectionSorter class listed above. It differs in that it uses a much different —and better— sorting algorithm, which is described on a web page to which there is a link (titled "Quicksort: A Recursive Sorting Algorithm") on the course web page. Almost all of the class, as given, can be left alone. All that is necessary for you to do is to supply the body of the sortAux() method (which is marked with the STUB! comment.

  For purposes of testing this class, you can use the SorterTester application mentioned above, but, in the sortArray() method, be sure to "uncomment" the line of code that creates the QuickSorter object (and comment out the line of code that creates the SelectionSorter object).

Program Submission

Use the file submission system (see the link near the top of the course web page) to submit into the prog4_dir folder the four Java classes that you were responsible for completing. Make sure to insert the standard comments near the top of each class. These should include your name, a list of names of persons who aided you in your work, and a description of any defects. If there are defects of which you are unaware, it probably means that you did a poor job of testing your work. Thus, of two submissions having similar defects, one in which those defects are acknowledged deserves a better grade than one in which they are not acknowledged.