/* From http://java.sun.com/docs/books/tutorial/index.html */
/*
* @(#)SortItem.java 1.17f 95/04/10 James Gosling
*
* Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this software
* and its documentation for NON-COMMERCIAL purposes and without
* fee is hereby granted provided that this copyright notice
* appears in all copies. Please refer to the file "copyright.html"
* for further important copyright and licensing information.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
* THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
* TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
* DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
*/
import java.awt.Color;
import java.awt.Graphics;
/**
* A simple applet class to demonstrate a sort algorithm. You can specify a
* sorting algorithm using the "alg" attribyte. When you click on the applet, a
* thread is forked which animates the sorting algorithm.
*
* @author James Gosling
* @version 1.17f, 10 Apr 1995
*/
public class SortItem extends java.applet.Applet implements Runnable {
/**
* The thread that is sorting (or null).
*/
private Thread kicker;
/**
* The array that is being sorted.
*/
int[] arr;
/**
* The high water mark.
*/
int h1 = -1;
/**
* The low water mark.
*/
int h2 = -1;
/**
* The name of the algorithm.
*/
String algName;
/**
* The sorting algorithm (or null).
*/
SortAlgorithm algorithm;
/**
* Fill the array with random numbers from 0..n-1.
*/
void scramble() {
int[] a = new int[size().height / 2];
double f = size().width / (double) a.length;
for (int i = a.length; --i >= 0;) {
a[i] = (int) (i * f);
}
for (int i = a.length; --i >= 0;) {
int j = (int) (i * Math.random());
int t = a[i];
a[i] = a[j];
a[j] = t;
}
arr = a;
}
/**
* Pause a while.
*
* @see SortAlgorithm
*/
void pause() {
pause(-1, -1);
}
/**
* Pause a while, and draw the high water mark.
*
* @see SortAlgorithm
*/
void pause(int H1) {
pause(H1, -1);
}
/**
* Pause a while, and draw the low&high water marks.
*
* @see SortAlgorithm
*/
void pause(int H1, int H2) {
h1 = H1;
h2 = H2;
if (kicker != null) {
repaint();
}
try {
Thread.sleep(20);
} catch (InterruptedException e) {
}
}
/**
* Initialize the applet.
*/
public void init() {
String at = getParameter("alg");
if (at == null) {
at = "BubbleSort";
}
algName = at + "Algorithm";
scramble();
setBackground(Color.white);
resize(100, 100);
}
/**
* Paint the array of numbers as a list of horizontal lines of varying
* lenghts.
*/
public void paint(Graphics g) {
int[] a = arr;
int y = size().height - 1;
// Erase old lines
g.setColor(Color.lightGray);
for (int i = a.length; --i >= 0; y -= 2) {
g.drawLine(arr[i], y, size().width, y);
}
// Draw new lines
g.setColor(Color.black);
y = size().height - 1;
for (int i = a.length; --i >= 0; y -= 2) {
g.drawLine(0, y, arr[i], y);
}
if (h1 >= 0) {
g.setColor(Color.red);
y = h1 * 2 + 1;
g.drawLine(0, y, size().width, y);
}
if (h2 >= 0) {
g.setColor(Color.blue);
y = h2 * 2 + 1;
g.drawLine(0, y, size().width, y);
}
}
/**
* Update without erasing the background.
*/
public void update(Graphics g) {
paint(g);
}
/**
* Run the sorting algorithm. This method is called by class Thread once the
* sorting algorithm is started.
*
* @see java.lang.Thread#run
* @see SortItem#mouseUp
*/
public void run() {
try {
if (algorithm == null) {
algorithm = (SortAlgorithm) Class.forName(algName)
.newInstance();
algorithm.setParent(this);
}
algorithm.init();
algorithm.sort(arr);
} catch (Exception e) {
}
}
/**
* Stop the applet. Kill any sorting algorithm that is still sorting.
*/
public synchronized void stop() {
if (kicker != null) {
try {
kicker.stop();
} catch (IllegalThreadStateException e) {
// ignore this exception
}
kicker = null;
}
if (algorithm != null) {
try {
algorithm.stop();
} catch (IllegalThreadStateException e) {
// ignore this exception
}
}
}
/**
* For a Thread to actually do the sorting. This routine makes sure we do
* not simultaneously start several sorts if the user repeatedly clicks on
* the sort item. It needs to be synchronoized with the stop() method
* because they both manipulate the common kicker variable.
*/
private synchronized void startSort() {
if (kicker == null || !kicker.isAlive()) {
scramble();
repaint();
kicker = new Thread(this);
kicker.start();
}
}
/**
* The user clicked in the applet. Start the clock!
*/
public boolean mouseUp(java.awt.Event evt, int x, int y) {
startSort();
return true;
}
}
/*
* @(#)BidirectionalBubbleSortAlgorithm.java 1.6f 95/01/31 James Gosling
*
* Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for NON-COMMERCIAL purposes and without fee is hereby granted
* provided that this copyright notice appears in all copies. Please refer to
* the file "copyright.html" for further important copyright and licensing
* information.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
* NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY
* LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES.
*/
/**
* A bi-directional bubble sort demonstration algorithm SortAlgorithm.java, Thu
* Oct 27 10:32:35 1994
*
* @author James Gosling
* @version 1.6f, 31 Jan 1995
*/
class BidirectionalBubbleSortAlgorithm extends SortAlgorithm {
void sort(int[] a) throws Exception {
int j;
int limit = a.length;
int st = -1;
while (st < limit) {
boolean flipped = false;
st++;
limit--;
for (j = st; j < limit; j++) {
if (stopRequested) {
return;
}
if (a[j] > a[j + 1]) {
int T = a[j];
a[j] = a[j + 1];
a[j + 1] = T;
flipped = true;
pause(st, limit);
}
}
if (!flipped) {
return;
}
for (j = limit; --j >= st;) {
if (stopRequested) {
return;
}
if (a[j] > a[j + 1]) {
int T = a[j];
a[j] = a[j + 1];
a[j + 1] = T;
flipped = true;
pause(st, limit);
}
}
if (!flipped) {
return;
}
}
pause(st, limit);
}
}
/*
* @(#)SortAlgorithm.java 1.6f 95/01/31 James Gosling
*
* Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for NON-COMMERCIAL purposes and without fee is hereby granted
* provided that this copyright notice appears in all copies. Please refer to
* the file "copyright.html" for further important copyright and licensing
* information.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
* NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY
* LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES.
*/
/**
* A generic sort demonstration algorithm SortAlgorithm.java, Thu Oct 27
* 10:32:35 1994
*
* @author James Gosling
* @version 1.6f, 31 Jan 1995
*/
class SortAlgorithm {
/**
* The sort item.
*/
private SortItem parent;
/**
* When true stop sorting.
*/
protected boolean stopRequested = false;
/**
* Set the parent.
*/
public void setParent(SortItem p) {
parent = p;
}
/**
* Pause for a while.
*/
protected void pause() throws Exception {
if (stopRequested) {
throw new Exception("Sort Algorithm");
}
parent.pause(parent.h1, parent.h2);
}
/**
* Pause for a while and mark item 1.
*/
protected void pause(int H1) throws Exception {
if (stopRequested) {
throw new Exception("Sort Algorithm");
}
parent.pause(H1, parent.h2);
}
/**
* Pause for a while and mark item 1 & 2.
*/
protected void pause(int H1, int H2) throws Exception {
if (stopRequested) {
throw new Exception("Sort Algorithm");
}
parent.pause(H1, H2);
}
/**
* Stop sorting.
*/
public void stop() {
stopRequested = true;
}
/**
* Initialize
*/
public void init() {
stopRequested = false;
}
/**
* This method will be called to sort an array of integers.
*/
void sort(int[] a) throws Exception {
}
}
/*
* @(#)QSortAlgorithm.java 1.6f 95/01/31 James Gosling
*
* Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this software
* and its documentation for NON-COMMERCIAL purposes and without
* fee is hereby granted provided that this copyright notice
* appears in all copies. Please refer to the file "copyright.html"
* for further important copyright and licensing information.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
* THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
* TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
* DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
*/
/**
* A quick sort demonstration algorithm
* SortAlgorithm.java, Thu Oct 27 10:32:35 1994
*
* @author James Gosling
* @version 1.6f, 31 Jan 1995
*/
class QSortAlgorithm extends SortAlgorithm {
void sort(int[] a, int lo0, int hi0) throws Exception {
int lo = lo0;
int hi = hi0;
pause(lo, hi);
if (lo >= hi) {
return;
}
int mid = a[(lo + hi) / 2];
while (lo < hi) {
while (lo lo++;
}
while (lo mid) {
hi--;
}
if (lo < hi) {
int T = a[lo];
a[lo] = a[hi];
a[hi] = T;
lo++;
hi--;
pause();
}
}
if (hi < lo) {
int T = hi;
hi = lo;
lo = T;
}
sort(a, lo0, lo);
sort(a, lo == lo0 ? lo+1 : lo, hi0);
}
void sort(int[] a) throws Exception {
sort(a, 0, a.length-1);
}
}
/*
* @(#)BubbleSortAlgorithm.java 1.6f 95/01/31 James Gosling
*
* Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this software
* and its documentation for NON-COMMERCIAL purposes and without
* fee is hereby granted provided that this copyright notice
* appears in all copies. Please refer to the file "copyright.html"
* for further important copyright and licensing information.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
* THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
* TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
* DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
*/
/**
* A bubble sort demonstration algorithm
* SortAlgorithm.java, Thu Oct 27 10:32:35 1994
*
* @author James Gosling
* @version 1.6f, 31 Jan 1995
*/
class BubbleSortAlgorithm extends SortAlgorithm {
void sort(int[] a) throws Exception {
for (int i = a.length; --i>=0; )
for (int j = 0; j if (stopRequested) {
return;
}
if (a[j] > a[j+1]) {
int T = a[j];
a[j] = a[j+1];
a[j+1] = T;
}
pause(i,j);
}
}
}