de.weaut.sortDemo

Class SortApp.SortAlgorithm

java.lang.Object

de.weaut.sortDemo.SortApp.SortAlgorithm

Direct Known Subclasses:

BidirectionalBubbleSort, BubbleSort, CombSort11, EQSort, ExtraStorageMergeSort, HeapSort, InsertionSort, MergeSort, QuickSort, RadixSort, SelectionSort, ShakerSort, ShellSort

Enclosing class:

SortApp

public abstract static class SortApp.SortAlgorithm
extends java.lang.Object

An abstract sorting algorithm for demonstrations.

Concrete algorithms for demonstrations by a SortApp object must extend this embedded class SortApp.SortAlgorithm.

© Copyright 2005 Albrecht Weinert
Hints on copyright and else see the containing class SortApp.

Hint: Using an embedded (static) class with explicit (cross) references to a parent SortApp object was a decision due to Applet problems with inner classes at least up to 2005. An inner class would, of course, be the natural choice here.

Version:

see embedding class SortApp

Author:

Albrecht Weinert

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	stopRequested Stop request.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	SortAlgorithm() Constructor for embedding class.

Method Summary

Modifier and Type	Method and Description
protected int	getMaxPossiVal() Highest possible random value of array elements.
protected boolean	pause() Have a break / make a pause.
protected boolean	pause(int item1) Have a break / make a pause.
protected boolean	pause(int item1, int item2) Have a break / make a pause and mark the sorting step.
protected abstract void	sort(int[] a) The real sorting method.
static void	startMe() Make an inheritor startable in an uniform way.
void	stop() Stop the sorting.
protected boolean	swap(int item1, int item2) A swap with pause and mark the sorting step.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

stopRequested

protected volatile boolean stopRequested

Stop request.

If true, stop sorting (sort(int[])) at once.

Constructor Detail

SortAlgorithm

protected SortAlgorithm()

Constructor for embedding class.

Method Detail

getMaxPossiVal

protected final int getMaxPossiVal()

Highest possible random value of array elements.

Hint: This will not have to be the real maximum after scrambling the array to be sorted.

pause

protected final boolean pause()

Have a break / make a pause.

Pauses re-using the former markers.

See Also:

pause(int, int)

pause

protected final boolean pause(int item1)

Have a break / make a pause.

Pauses re-using the former lower marker.

See Also:

pause(int, int)

pause

protected final boolean pause(int item1,
                              int item2)

Have a break / make a pause and mark the sorting step.

This callback must be used directly or indirectly by the sorting algorithm's implementation (sort(int[])) after every (substantial) step. The parameters item1 and item2 are markers / indices in the array describing the current sorting state.
A -1 means omit the respective marker.

Parameters:

item1 - Index A in the array to be sorted relating to the step / state

item2 - Index B in the array to be sorted relating to the step / state

Returns:

true, if stop / break the demo is requested

swap

protected final boolean swap(int item1,
                             int item2)

A swap with pause and mark the sorting step.

This method swaps the array elements [item1] and [item2] and pauses marks this step.
Hint: Contrary to using the method pause(int, int) directly -1 or other out of bound values to omit or hide ar marker are forbidden here.

Parameters:

item1 - Index A of one element to be swapped

item2 - Index B of one element to be swapped

Returns:

true, if stop / break the demo is requested

stop

public void stop()

Stop the sorting.

This implementation just sets stopRequested true. Implementations of sort(int[]) must react accordingly.

sort

protected abstract void sort(int[] a)

The real sorting method.

This method has to sort the array provided as parameter. Every substantial algorithmic step has to be marked by calling one of the callback methods pause(int, int), pause(int), pause() directly or indirectly by utilising swap(int, int) for element exchanges within the array having been provided to this sort implementation.
This pausing does all else like counting steps, displaying the sorting state and else.

As substantial step to be treated this way we see

• Assignments respectively swaps within the array to be sorted
  and (only in a first loop through the array) also
• a reading / comparing access to to one or two elements.

startMe

public static void startMe()

Make an inheritor startable in an uniform way.

Call this (dirty, dirty) method in the inheritors main(Strting[] args); args are irrelevant.

See Also:

SortApp.main(String[])