<< Chapter < Page | Chapter >> Page > |
Tradionally, an in-place insertion sort is performed by starting from one end of the arry, say the left end, and performing an in-order insertion of an element into the sub-array to its left. The next element to the right is then chosen and the insertion process repeated. At each insertion, the sorted sub-array on the left grows until encompasses the entire array. An insertion sort is a very typical way in which people will order a set of playing cards in their hand.
Below is an animation of a traditional insertion sort algorithm:
In the Merrit paradigm, the insertion sort first splits the array or sub-array into two pieces simply by separating the right-most element. Recursively, the splitting process proceeds to from the right to the left until a single element is left in the sub-array. Sorting a one element array is a no-op, so then the recursion unwinds with the join process. The join process combines each single split-off element with its sorted sub-array partner to its left by performing an in-order insertion. This proceeds as the recusion unwinds until the entire array is fully sorted. In contrast to the selection sort, the bulk of the work is being done in the join method, hence classifying insertion sort as an "easy split, hard join" sorting process.
Below is an animation of a Merritt insertion sort algorithm:
In the Java implementation of the selection sorter below, the
split
method simply splits off the right-most element of the sub-array. The
join
method performs an in-order insertion of the single split-off element into the larger sub-array to its left.
Insertionsorter class
package sorter;
/*** A concrete sorter that uses the Insertion Sort technique.
*/public class InsertionSorter extends ASorter
{/**
* The constructor for this class.* @param iCompareOp The comparison strategy to use in the sorting.
*/public InsertionSorter(AOrder iCompareOp)
{super(iCompareOp);
}/**
* Splits A[lo:hi]into A[lo:s-1] and A[s:hi]where s is the returned value of this function.
* This simply splits off the element at index hi.* @param A the array A[lo:hi] to be sorted.* @param lo the low index of A.
* @param hi the high index of A.* @return hi always.
*/protected int split(Object[] A, int lo, int hi){
return (hi);}
/*** Joins sorted A[lo:s-1] and sorted A[s:hi]into A[lo:hi]. (s = hi)* The method performs an in-order insertion of A[hi] into the A[lo, hi-1]* @param A A[lo:s-1] and A[s:hi]are sorted.
* @param lo the low index of A.* @param s
* @param hi the high index of A.*/
protected void join(Object[]A, int lo, int s, int hi)
{int j = hi; // remember s == hi.
Object key = A[hi];
// Invariant: A[lo:j-1]and A[j+1:hi] are sorted and key<all elements of A[j+1:hi].// Shifts elements of A[lo:j-1] that are greater than key to the "right" to make room// for key.
while (lo<j&&aOrder.lt(key, A[j-1])){
A[j]= A[j-1];A[j-1] = key;j = j - 1; // invariant is maintained.
} // On loop exit: j = lo or A[j-1]<= key. Also invariant is still true.
// A[j]= key;
}}
The authors were once challenged that the Merritt template-based sorting paradigm could not be used to describe the Shaker Sort process (a bidirectional Bubble or Selection sort). See for instance, (External Link) . However, it can be done is a very straightforward manner. There are a number of viable solutions. Hint: think about the State Design Pattern .
The solution is left to the student but is available from the authors if proof of non-student status is provided.
For more examples, please see download the demo code . Please note that the ShakerSort code is disabled due to its use as a student exercise.
Notification Switch
Would you like to follow the 'Principles of object-oriented programming' conversation and receive update notifications?