Sorting Types 2

/*
* @(#)BubbleSortAlgorithm.java
1.6 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.6, 31 Jan 1995

*
* Modified 23 Jun 1995 by Jason Harrison@cs.ubc.ca:
* Algorithm completes early when no items have been swapped in the
* last pass.
*
* 27 Nov 2006: (bwbecker@uwaterloo.ca) Changed the overall architecture
to
* use model-view-controller. Re-examined algorithm to ensure that counting
* was consistent across all algorithms (the quicksorts used to ignore most
* of the comparisons in the partitioning, for example).
*/
class BubbleSort2Algorithm extends SortAlgorithm
{
void sort(int a[])
{
for (int i = a.length; --i >= 0;)
{
boolean flipped = false;
for (int j = 0; j < i; j++)
{
if (stopRequested)
{
return;
}
super.compares++;
super.activeMarker = j;
if (a[j] > a[j + 1])

{
int T = a[j];
a[j] = a[j + 1];
a[j + 1] = T;
super.moves++;
flipped = true;
}
super.updateAllViews();
}
if (!flipped)
{
super.updateAllViews(-1, -1);
return;
}
super.hiMarker = i;
}
}
}
/*
* @(#)SelectionSortAlgorithm.java
*
1.0 95/06/23 Jason Harrison
* Copyright (c) 1995 University of British Columbia

*
*
* UBC MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE
SUITABILITY OF
LIMITED
* PARTICULAR PURPOSE, OR NON-INFRINGEMENT. UBC SHALL NOT BE LIABLE
FOR
OR
*/
/**
* A selection sort demonstration algorithm SortAlgorithm.java, Thu Oct 27
* 10:32:35 1994
*
* @author Jason Harrison@cs.ubc.ca
* @version 1.0, 23 Jun 1995
*
*

to
*/
class SelectionSortAlgorithm extends SortAlgorithm
{
void sort(int a[])
{
for (int i = 0; i < a.length; i++)
{
super.lowMarker = i;
int min = i;
int j;
/*
* Find the smallest element in the unsorted list
*/
for (j = i + 1; j < a.length; j++)
{
if (stopRequested)
{
return;
}
if (a[j] < a[min])
{
min = j;
}
super.compares++;
}
/*
* Swap the smallest unsorted element into the end of the
sorted list.
*/
int T = a[min];
a[min] = a[i];
a[i] = T;
super.moves++;
super.activeMarker = i;
}
}
}
/*
* @(#)SelectionSortAlgorithm.java
1.0 95/06/23 Jason Harrison
*
*
*
SUITABILITY OF
LIMITED
FOR
OR
*/
/**
* A selection sort demonstration algorithm SortAlgorithm.java, Thu Oct 27
* 10:32:35 1994
*
* @version 1.0, 23 Jun 1995
*
*
to
*/
class SelectionSortAlgorithm extends SortAlgorithm
{
void sort(int a[])
{
for (int i = 0; i < a.length; i++)
{
super.lowMarker = i;
int min = i;
int j;
/*
* Find the smallest element in the unsorted list
*/
for (j = i + 1; j < a.length; j++)
{
if (stopRequested)
{
return;
}
if (a[j] < a[min])
{
min = j;
}
super.compares++;
}
/*
* Swap the smallest unsorted element into the end of the
sorted list.
*/
int T = a[min];
a[min] = a[i];
a[i] = T;
super.moves++;
super.activeMarker = i;
}
}
}
/*
* @(#)ExtraStorageMergeSortAlgorithm.java 1.0 97/01/09 Jack Snoeyink
*
*
*
SUITABILITY OF
LIMITED
FOR
OR
*/
/**
* A merge sort demonstration algorithm using extra space
*
* @author Jack Snoeyink@cs.ubc.ca
* @version 1.0, 09 Jan 97
*
to

*/
class ExtraStorageMergeSortAlgorithm extends SortAlgorithm
{
void sort(int a[], int lo, int hi, int scratch[])
{
super.updateAllViews(lo, hi);
if (super.stopRequested)
{
return;
}
if (lo >= hi)

{
return; /* a[lo] is sorted already */
}
int mid = (lo + hi) / 2;

sort(a, lo, mid, scratch); /* Sort sublist a[lo..mid] */
sort(a, mid + 1, hi, scratch); /* Sort sublist a[mid+1..hi] */
{
return;
}
// Merge results
int k, t_lo = lo, t_hi = mid + 1;
super.lowMarker = lo;
super.hiMarker = hi;
for (k = lo; k <= hi; k++)
{
/* Merge sorted sublists
*/
super.compares++;
if ((t_lo <= mid) && ((t_hi > hi) || (a[t_lo] < a[t_hi])))
{
scratch[k] = a[t_lo++];
} else
{
scratch[k] = a[t_hi++];
}
super.moves++;
super.activeMarker = k;
}
for (k = lo; k <= hi; k++)

{
a[k] = scratch[k]; /* Copy back to a */
super.moves++;
}
}
void sort(int a[])

{
int scratch[] = new int[a.length];
sort(a, 0, a.length - 1, scratch);
}
}
/**
* A merge sort demonstration algorithm using extra space
* without recursion.
*
* @author Byron Weber Becker (bwbecker@uwaterloo.ca)
* @version 1.0, 2009 Mar 17
*
*/
class BottomupMergeSortAlgorithm extends SortAlgorithm
{
void sort(int a[], int lo, int hi, int scratch[])
{
super.updateAllViews(lo, hi);
{
return;
}
if (lo >= hi)

{
return; /* a[lo] is sorted already */
}
int mid = (lo + hi) / 2;

sort(a, lo, mid, scratch); /* Sort sublist a[lo..mid] */
sort(a, mid + 1, hi, scratch); /* Sort sublist a[mid+1..hi] */
{
return;
}
// Merge results
int k, t_lo = lo, t_hi = mid + 1;
super.lowMarker = lo;
super.hiMarker = hi;
for (k = lo; k <= hi; k++)

{
/* Merge sorted sublists
*/
super.compares++;
if ((t_lo <= mid) && ((t_hi > hi) || (a[t_lo] < a[t_hi])))
{
scratch[k] = a[t_lo++];
} else
{
scratch[k] = a[t_hi++];
}
super.moves++;
}
for (k = lo; k <= hi; k++)

{
a[k] = scratch[k]; /* Copy back to a */
super.moves++;
}
}
void sort(int a[])
{
int n = a.length;
int work[] = new int[n];
for(int msize = 1; msize < n; msize = msize * 2)

{
for(int i=0; i<n; i = i + (msize*2))
{
if (super.stopRequested) return;
int mlo = i;
int mid = i + msize;
/* odd # of subarrays? */
if (mid >= n) break;
int mhi = i + (msize * 2) - 1;
/* short last subarray? */

if (mhi >= n)
mhi = n-1;
/* Merge a[mlo..mid-1] and a[mid..mhi] */

int il = mlo;
int ir = mid;
int iw = mlo;
super.updateAllViews(mlo, mhi);
while (il < mid && ir <= mhi)
{
if (a[il] < a[ir])
work[iw++] = a[il++];
else
work[iw++] = a[ir++];
super.compares++;
super.moves++;
super.activeMarker = iw;
}
while (il < mid)
{
work[iw++] = a[il++];
super.compares++;
}
while (ir <= mhi)
{
work[iw++] = a[ir++];
super.compares++;
// Copy back to a
for(iw = mlo; iw <= mhi; iw++)
{
a[iw] = work[iw];
super.moves++;
super.activeMarker = iw;
}
}
}
}
}
/*
* @(#)ShellSortAlgorithm.java 1.1 2000/04/12 Jason Harrison
*
*
*
SUITABILITY OF
LIMITED
FOR

OR
*/
/**
* A shell sort demonstration algorithm
* Note: Invented by Donald Lewis Shell [CACM, July, 1959, pages 30-32]
*
* http://www.auto.tuwien.ac.at/~blieb/woop/shell.html
*
* Shellsort is a simple extension of insertion sort which gains speed
* by allowing exchanges of elements that are far apart. The idea is
* to rearrange the array to give it the property that every hth
* element (starting anywhere) yields a sorted array. Such an array
* is said to be h-sorted.
*
* By h-sorting for some large values of h, we can move elements in
* the array long distances and thus make it easier to h-sort for
* smaller values of h. Using such a procedure for any sequence of
* values h which ends in 1 will produce a sorted array.
*
* @version 1.0, 23 Jun 1995
* @version 1.1, 12 Apr 2000
*
-- fixed java.lang.ArrayIndexOutOfBoundsException
Joel Berry <jmbshifty@yahoo.com> found this bug
*
to
*/
class ShellSortAlgorithm extends SortAlgorithm
{
void sort(int a[])
{
int h = 1;
/*
* find the largest h value possible
*/
while ((h * 3 + 1) < a.length)
{
h = 3 * h + 1;
}
/*
* while h remains larger than 0
*/
while (h > 0)
{
/*
* for each set of elements (there are h sets)

*/
for (int i = h - 1; i < a.length; i++)
{
super.hiMarker = i;
/*
* pick the last element in the set
*/
int B = a[i];
super.other++;
int j = i;
/*
* compare the element at B to the one before it in
the set if they
* are out of order continue this loop, moving
elements "back" to
* make room for B to be inserted.
*/
super.compares++;
for (j = i; (j >= h) && (a[j - h] > B); j -= h)
{
a[j] = a[j - h];
super.compares++;
loop
super.moves++;
// test in for-
if (stopRequested)
{
return;
}
}
/*
* insert B into the correct place
*/
a[j] = B;
super.moves++;
}
/*
* all sets h-sorted, now decrease set size
*/
h = h / 3;
}
}
}
/*
* @(#)HeapSortAlgorithm.java 1.0 95/06/23 Jason Harrison
*
*
*
SUITABILITY OF
LIMITED
FOR
OR
*/
/**
* A heap sort demonstration algorithm
*
* @version 1.0, 23 Jun 1995
*
to

*/
class HeapSortAlgorithm extends SortAlgorithm
{
void sort(int a[])
{
int N = a.length;
// Build the heap
for (int k = N / 2; k > 0; k--)
{
downheap(a, k, N);
}
// Sort the data

super.hiMarker = N;
do
{
{
return;
}
int T = a[0];
a[0] = a[N - 1];

a[N - 1] = T;
super.moves++;
N = N - 1;
super.lowMarker = N;
downheap(a, 1, N);
} while (N > 1);
}
void downheap(int a[], int k, int N)

{
int T = a[k - 1];
super.other++;
while (k <= N / 2)
{
{
return;
}
int j = k + k;
super.compares++;
if ((j < N) && (a[j - 1] < a[j]))
{
j++;
}
super.compares++;
if (T >= a[j - 1])
{
break;
} else
{
a[k - 1] = a[j - 1];
super.moves++;
super.activeMarker = k-1;
k = j;
}
}
a[k - 1] = T;
super.moves++;
}
}
/*
* @(#)QSortAlgorithm.java
1.6f 95/01/31 James Gosling
*
* Copyright (c) 1994-1995 Sun Microsystems, Inc. All Rights Reserved.
*

* and its documentation for NON-COMMERCIAL or COMMERCIAL purposes
and
* without fee is hereby granted.
* Please refer to the file http://java.sun.com/copy_trademarks.html
* for further important copyright and trademark information and to
* http://java.sun.com/licensing.html for further important licensing
* information for the Java (tm) Technology.
*
SUITABILITY OF
LIMITED
FOR
OR
*
* THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS
ON-LINE
* CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAILSAFE
* 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
*
* @version 1.6f, 31 Jan 1995
*
*
* 19 Feb 1996: Fixed to avoid infinite loop discoved by Paul Haeberli.
*
Misbehaviour expressed when the pivot element was not unique.
-Jason Harrison
*
* 21 Jun 1996: Modified code based on comments from Paul Haeberli, and
*
Peter Schweizer (Peter.Schweizer@mni.fh-giessen.de).
Used Daeron Meyer's (daeron@geom.umn.edu) code for the
new pivoting code. - Jason Harrison
*
* 09 Jan 1998: Another set of bug fixes by Thomas Everth
(everth@wave.co.nz)
and John Brzustowski (jbrzusto@gpu.srv.ualberta.ca).
*
* 27 Nov 2006: (bwbecker@uwaterloo.ca) Cloned QSortAlgorithm. This one
uses
* a[hi] as the pivot to show the abysmal performance with a poor pivot
choice.
* Changed the overall architecture to
*/
class NaiveQuickSortAlgorithm extends SortAlgorithm
{
void sort(int a[], int lo0, int hi0)
{
int lo = lo0;
int hi = hi0;
super.lowMarker = lo0;
super.hiMarker = hi0;
if (lo >= hi)
{
return;
} else if (lo == hi - 1)
{
/*
* sort a two element list by swapping if necessary
*/
if (a[lo] > a[hi])

{
int T = a[lo];
a[lo] = a[hi];
a[hi] = T;
super.moves++;
}
return;
}
/*
* Pick a pivot. This one is pretty 'naive' (dumb) for the worst
case.
*/
int pivot = a[hi];
super.other++;
while (lo < hi)

{
/*
* Search forward from a[lo] until an element is found
that
* is greater than the pivot or lo >= hi
*/
super.compares++;
while (a[lo] <= pivot && lo < hi)
{
lo++;
super.compares++;
}
/*
* Search backward from a[hi] until element is found that
* is less than the pivot, or lo >= hi
*/
super.compares++;
while (pivot <= a[hi] && lo < hi)
{
hi--;
super.compares++;
}
/*
* Swap elements a[lo] and a[hi]
*/
if (lo < hi)
{
int T = a[lo];
a[lo] = a[hi];
a[hi] = T;
super.moves++;
}
if (stopRequested)
{
return;
}
}
/*
* Put the median in the "center" of the list
*/
a[hi0] = a[hi];
a[hi] = pivot;
super.moves += 2;
/*
* Recursive calls, elements a[lo0] to a[lo-1] are less than or
* equal to pivot, elements a[hi+1] to a[hi0] are greater than
* pivot.
*/
sort(a, lo0, lo - 1);
sort(a, hi + 1, hi0);
}
void sort(int a[])
{
sort(a, 0, a.length - 1);
}
}
/*
* @(#)QSortAlgorithm.java
1.6f 95/01/31 James Gosling
*
* Copyright (c) 1994-1995 Sun Microsystems, Inc. All Rights Reserved.
*
* and its documentation for NON-COMMERCIAL or COMMERCIAL purposes
and
* without fee is hereby granted.
* Please refer to the file http://java.sun.com/copy_trademarks.html
* for further important copyright and trademark information and to
* http://java.sun.com/licensing.html for further important licensing
* information for the Java (tm) Technology.
*
SUITABILITY OF
LIMITED
FOR
OR
*
* THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS
ON-LINE
* CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAILSAFE
* 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
*
* @version 1.6f, 31 Jan 1995
*/
/**
* 19 Feb 1996: Fixed to avoid infinite loop discoved by Paul Haeberli.

*
Misbehaviour expressed when the pivot element was not unique.
-Jason Harrison
*
* 21 Jun 1996: Modified code based on comments from Paul Haeberli, and
*
Peter Schweizer (Peter.Schweizer@mni.fh-giessen.de).
Used Daeron Meyer's (daeron@geom.umn.edu) code for the
new pivoting code. - Jason Harrison
*
* 09 Jan 1998: Another set of bug fixes by Thomas Everth
(everth@wave.co.nz)
*
and John Brzustowski (jbrzusto@gpu.srv.ualberta.ca).
*
to
*/
class QSortAlgorithm extends SortAlgorithm

{
void sort(int a[], int lo0, int hi0)
{
int lo = lo0;
int hi = hi0;
super.lowMarker = lo0;
super.hiMarker = hi0;
if (lo >= hi)
{
return;
} else if (lo == hi - 1)
{
/*
* sort a two element list by swapping if necessary
*/
if (a[lo] > a[hi])
{
int T = a[lo];
a[lo] = a[hi];
a[hi] = T;
super.moves++;
}
return;
}
/*
* Pick a pivot and move it out of the way
*/
int pivot = a[(lo + hi) / 2];
a[(lo + hi) / 2] = a[hi];
a[hi] = pivot;
super.other += 3;
while (lo < hi)

{
/*
* Search forward from a[lo] until an element is found
that
* is greater than the pivot or lo >= hi
*/
super.compares++;
while (a[lo] <= pivot && lo < hi)
{
lo++;
super.compares++;
}
/*
* Search backward from a[hi] until element is found that
* is less than the pivot, or lo >= hi
*/
super.compares++;
while (pivot <= a[hi] && lo < hi)
{
hi--;
super.compares++;
}
/*
* Swap elements a[lo] and a[hi]
*/
if (lo < hi)
{
int T = a[lo];
a[lo] = a[hi];
a[hi] = T;
super.moves++;
}
if (stopRequested)
{
return;
}
}
/*
* Put the median in the "center" of the list
*/
a[hi0] = a[hi];
a[hi] = pivot;
super.moves += 2;
/*
* Recursive calls, elements a[lo0] to a[lo-1] are less than or
* equal to pivot, elements a[hi+1] to a[hi0] are greater than
* pivot.
*/
sort(a, lo0, lo - 1);
sort(a, hi + 1, hi0);
}
void sort(int a[])

{
sort(a, 0, a.length - 1);
}
}

Sorting Types 2

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Sorting Types 2

Diunggah oleh

Hak Cipta:

Format Tersedia

/*

1.6 95/01/31 James Gosling

* @version 1.6, 31 Jan 1995

if (a[j] > a[j + 1])

1.0 95/06/23 Jason Harrison

* Copyright (c) 1995 University of British Columbia

* 27 Nov 2006: (bwbecker@uwaterloo.ca) Changed the overall architecture

if (a[j] < a[min])

1.0 95/06/23 Jason Harrison

if (a[j] < a[min])

* use model-view-controller. Re-examined algorithm to ensure that counting

if (lo >= hi)

int mid = (lo + hi) / 2;

for (k = lo; k <= hi; k++)

void sort(int a[])

if (lo >= hi)

int mid = (lo + hi) / 2;

for (k = lo; k <= hi; k++)

for (k = lo; k <= hi; k++)

void sort(int a[])

for(int msize = 1; msize < n; msize = msize * 2)

int mhi = i + (msize * 2) - 1;

/* short last subarray? */

/* Merge a[mlo..mid-1] and a[mid..mhi] */

* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING

Joel Berry <jmbshifty@yahoo.com> found this bug

* for each set of elements (there are h sets)

* use model-view-controller. Re-examined algorithm to ensure that counting

// Sort the data

a[0] = a[N - 1];

void downheap(int a[], int k, int N)

1.6f 95/01/31 James Gosling

* Permission to use, copy, modify, and distribute this software

* SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR

Misbehaviour expressed when the pivot element was not unique.

Peter Schweizer (Peter.Schweizer@mni.fh-giessen.de).

Used Daeron Meyer's (daeron@geom.umn.edu) code for the

new pivoting code. - Jason Harrison

and John Brzustowski (jbrzusto@gpu.srv.ualberta.ca).

if (a[lo] > a[hi])

while (lo < hi)

void sort(int a[])

1.6f 95/01/31 James Gosling

* 19 Feb 1996: Fixed to avoid infinite loop discoved by Paul Haeberli.

Misbehaviour expressed when the pivot element was not unique.

Peter Schweizer (Peter.Schweizer@mni.fh-giessen.de).

Used Daeron Meyer's (daeron@geom.umn.edu) code for the

new pivoting code. - Jason Harrison

and John Brzustowski (jbrzusto@gpu.srv.ualberta.ca).

class QSortAlgorithm extends SortAlgorithm

while (lo < hi)

void sort(int a[])

Anda mungkin juga menyukai