Fast QSort Algorithm

by Vijayaprasad 2010-01-28 16:08:29

/*
* @(#)QSortAlgorithm.java 1.3 29 Feb 1996 James Gosling
*
* Copyright (c) 1994-1996 Sun Microsystems, Inc. All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this software
* and its documentation for NON-COMMERCIAL or COMMERCIAL purposes and
* without fee is hereby granted.
* Please refer to the file http://www.javasoft.com/copy_trademarks.html
* for further important copyright and trademark information and to
* http://www.javasoft.com/licensing.html for further important
* licensing information for the Java (tm) Technology.
*
* 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.
*
* THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS ON-LINE
* CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE
* PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT
* NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE
* SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE
* SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE
* PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH RISK ACTIVITIES"). SUN
* SPECIFICALLY DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR
* HIGH RISK ACTIVITIES.
*/

/**
* A quick sort demonstration algorithm
* SortAlgorithm.java
*
* @author James Gosling
* @author Kevin A. Smith
* @version @(#)QSortAlgorithm.java 1.3, 29 Feb 1996
* extended with TriMedian and InsertionSort by Denis Ahrens
* with all the tips from Robert Sedgewick (Algorithms in C++).
* It uses TriMedian and InsertionSort for lists shorts than 4.
* <fuhrmann@cs.tu-berlin.de>
*/
public class FastQSortAlgorithm extends SortAlgorithm
{
/** This is a generic version of C.A.R Hoare's Quick Sort
* algorithm. This will handle arrays that are already
* sorted, and arrays with duplicate keys.<BR>
*
* If you think of a one dimensional array as going from
* the lowest index on the left to the highest index on the right
* then the parameters to this function are lowest index or
* left and highest index or right. The first time you call
* this function it will be with the parameters 0, a.length - 1.
*
* @param a an integer array
* @param lo0 left boundary of array partition
* @param hi0 right boundary of array partition
*/
private void QuickSort(int a[], int l, int r) throws Exception
{
int M = 4;
int i;
int j;
int v;

if ((r-l)>M)
{
i = (r+l)/2;
if (a[l]>a[i]) swap(a,l,i); // Tri-Median Methode!
if (a[l]>a[r]) swap(a,l,r);
if (a[i]>a[r]) swap(a,i,r);

j = r-1;
swap(a,i,j);
i = l;
v = a[j];
for(;;)
{
while(a[++i]<v);
while(a[--j]>v);
if (j<i) break;
swap (a,i,j);
pause(i,j);
if (stopRequested) {
return;
}
}
swap(a,i,r-1);
pause(i);
QuickSort(a,l,j);
QuickSort(a,i+1,r);
}
}

private void swap(int a[], int i, int j)
{
int T;
T = a[i];
a[i] = a[j];
a[j] = T;
}

private void InsertionSort(int a[], int lo0, int hi0) throws Exception
{
int i;
int j;
int v;

for (i=lo0+1;i<=hi0;i++)
{
v = a[i];
j=i;
while ((j>lo0) && (a[j-1]>v))
{
a[j] = a[j-1];
pause(i,j);
j--;
}
a[j] = v;
}
}

public void sort(int a[]) throws Exception
{
QuickSort(a, 0, a.length - 1);
InsertionSort(a,0,a.length-1);
pause(-1,-1);
}
}

Tagged in:

1086
like
0
dislike
0
mail
flag

You must LOGIN to add comments