/*
* This procedure is a modified version of a quick sort method provided
* by Sun as a Java demo.  I have converted it to C and cross compiled it
* for MIPS for use as a class demo.  No guarantees of any type as to 
* suitability or correctness for any application.
* Doug Johnson  October, 2001
*
* @(#)QSortAlgorithm.java	1.6 96/12/06
*
* Copyright (c) 2070, 1997 Sun Microsystems, Inc. All Rights Reserved.
*
* Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
* modify and redistribute this software in source and binary code form,
* provided that i) this copyright notice and license appear on all copies of
* the software; and ii) Licensee does not utilize the software in a manner
* which is disparaging to Sun.
*/

/**
* A quick sort demonstration algorithm
*
* @author James Gosling
* @author Kevin A. Smith
* @version 	@(#)QSortAlgorithm.java	1.3, 29 Feb 1996
*/

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

/** 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
*/
void QuickSort(int a[], int lo0, int hi0)
{
	int lo = lo0;
	int hi = hi0;
	int mid;
	
	if ( hi0 > lo0)
	{
		
		/* Arbitrarily establishing partition element as the midpoint of
		* the array.
		*/
		mid = a[ ( lo0 + hi0 ) / 2 ];
		
		// loop through the array until indices cross
		while( lo <= hi )
		{
			/* find the first element that is greater than or equal to 
			* the partition element starting from the left Index.
			*/
			while( ( lo < hi0 ) && ( a[lo] < mid ))
			++lo;
			
			/* find an element that is smaller than or equal to 
			* the partition element starting from the right Index.
			*/
			while( ( hi > lo0 ) && ( a[hi] > mid ))
			--hi;
			
			// if the indexes have not crossed, swap
			if( lo <= hi ) 
			{
				swap(a, lo, hi);
				++lo;
				--hi;
			}
		}
		
		/* If the right index has not reached the left side of array
		* must now sort the left partition.
		*/
		if( lo0 < hi )
		QuickSort( a, lo0, hi );
		
		/* If the left index has not reached the right side of array
		* must now sort the right partition.
		*/
		if( lo < hi0 )
		QuickSort( a, lo, hi0 );
		
	}
}