programming-examples/c++/Others/Sort.h - A collection of sorting and selection routines.cpp
2019-11-15 12:59:38 +01:00

363 lines
12 KiB
C++

Sort.h - A collection of sorting and selection routines
#ifndef SORT_H_
#define SORT_H_
#define merge Merge
#define swap Swap
/**
* Several sorting routines.
* Arrays are rearranged with smallest item first.
*/
#include "vector.h"
/**
* Simple insertion sort.
*/
template <class Comparable>
void insertionSort( vector<Comparable> & a )
{
/* 1*/ for( int p = 1; p < a.size( ); p++ )
{
/* 2*/ Comparable tmp = a[ p ];
int j;
/* 3*/ for( j = p; j > 0 && tmp < a[ j - 1 ]; j-- )
/* 4*/ a[ j ] = a[ j - 1 ];
/* 5*/ a[ j ] = tmp;
}
}
/**
* Shellsort, using Shell's (poor) increments.
*/
template <class Comparable>
void shellsort( vector<Comparable> & a )
{
for( int gap = a.size( ) / 2; gap > 0; gap /= 2 )
for( int i = gap; i < a.size( ); i++ )
{
Comparable tmp = a[ i ];
int j = i;
for( ; j >= gap && tmp < a[ j - gap ]; j -= gap )
a[ j ] = a[ j - gap ];
a[ j ] = tmp;
}
}
/**
* Standard heapsort.
*/
template <class Comparable>
void heapsort( vector<Comparable> & a )
{
/* 1*/ for( int i = a.size( ) / 2; i >= 0; i-- ) /* buildHeap */
/* 2*/ percDown( a, i, a.size( ) );
/* 3*/ for( int j = a.size( ) - 1; j > 0; j-- )
{
/* 4*/ swap( a[ 0 ], a[ j ] ); /* deleteMax */
/* 5*/ percDown( a, 0, j );
}
}
/**
* Internal method for heapsort.
* i is the index of an item in the heap.
* Returns the index of the left child.
*/
inline int leftChild( int i )
{
return 2 * i + 1;
}
/**
* Internal method for heapsort that is used in
* deleteMax and buildHeap.
* i is the position from which to percolate down.
* n is the logical size of the binary heap.
*/
template <class Comparable>
void percDown( vector<Comparable> & a, int i, int n )
{
int child;
Comparable tmp;
/* 1*/ for( tmp = a[ i ]; leftChild( i ) < n; i = child )
{
/* 2*/ child = leftChild( i );
/* 3*/ if( child != n - 1 && a[ child ] < a[ child + 1 ] )
/* 4*/ child++;
/* 5*/ if( tmp < a[ child ] )
/* 6*/ a[ i ] = a[ child ];
else
/* 7*/ break;
}
/* 8*/ a[ i ] = tmp;
}
/**
* Mergesort algorithm (driver).
*/
template <class Comparable>
void mergeSort( vector<Comparable> & a )
{
vector<Comparable> tmpArray( a.size( ) );
mergeSort( a, tmpArray, 0, a.size( ) - 1 );
}
/**
* Internal method that makes recursive calls.
* a is an array of Comparable items.
* tmpArray is an array to place the merged result.
* left is the left-most index of the subarray.
* right is the right-most index of the subarray.
*/
template <class Comparable>
void mergeSort( vector<Comparable> & a,
vector<Comparable> & tmpArray, int left, int right )
{
if( left < right )
{
int center = ( left + right ) / 2;
mergeSort( a, tmpArray, left, center );
mergeSort( a, tmpArray, center + 1, right );
merge( a, tmpArray, left, center + 1, right );
}
}
/**
* Internal method that merges two sorted halves of a subarray.
* a is an array of Comparable items.
* tmpArray is an array to place the merged result.
* leftPos is the left-most index of the subarray.
* rightPos is the index of the start of the second half.
* rightEnd is the right-most index of the subarray.
*/
template <class Comparable>
void merge( vector<Comparable> & a, vector<Comparable> & tmpArray,
int leftPos, int rightPos, int rightEnd )
{
int leftEnd = rightPos - 1;
int tmpPos = leftPos;
int numElements = rightEnd - leftPos + 1;
// Main loop
while( leftPos <= leftEnd && rightPos <= rightEnd )
if( a[ leftPos ] <= a[ rightPos ] )
tmpArray[ tmpPos++ ] = a[ leftPos++ ];
else
tmpArray[ tmpPos++ ] = a[ rightPos++ ];
while( leftPos <= leftEnd ) // Copy rest of first half
tmpArray[ tmpPos++ ] = a[ leftPos++ ];
while( rightPos <= rightEnd ) // Copy rest of right half
tmpArray[ tmpPos++ ] = a[ rightPos++ ];
// Copy tmpArray back
for( int i = 0; i < numElements; i++, rightEnd-- )
a[ rightEnd ] = tmpArray[ rightEnd ];
}
/**
* Quicksort algorithm (driver).
*/
template <class Comparable>
void quicksort( vector<Comparable> & a )
{
quicksort( a, 0, a.size( ) - 1 );
}
/**
* Standard swap
*/
template <class Comparable>
inline void swap( Comparable & obj1, Comparable & obj2 )
{
Comparable tmp = obj1;
obj1 = obj2;
obj2 = tmp;
}
/**
* Return median of left, center, and right.
* Order these and hide the pivot.
*/
template <class Comparable>
const Comparable & median3( vector<Comparable> & a, int left, int right )
{
int center = ( left + right ) / 2;
if( a[ center ] < a[ left ] )
swap( a[ left ], a[ center ] );
if( a[ right ] < a[ left ] )
swap( a[ left ], a[ right ] );
if( a[ right ] < a[ center ] )
swap( a[ center ], a[ right ] );
// Place pivot at position right - 1
swap( a[ center ], a[ right - 1 ] );
return a[ right - 1 ];
}
/**
* Internal quicksort method that makes recursive calls.
* Uses median-of-three partitioning and a cutoff of 10.
* a is an array of Comparable items.
* left is the left-most index of the subarray.
* right is the right-most index of the subarray.
*/
template <class Comparable>
void quicksort( vector<Comparable> & a, int left, int right )
{
/* 1*/ if( left + 10 <= right )
{
/* 2*/ Comparable pivot = median3( a, left, right );
// Begin partitioning
/* 3*/ int i = left, j = right - 1;
/* 4*/ for( ; ; )
{
/* 5*/ while( a[ ++i ] < pivot ) { }
/* 6*/ while( pivot < a[ --j ] ) { }
/* 7*/ if( i < j )
/* 8*/ swap( a[ i ], a[ j ] );
else
/* 9*/ break;
}
/*10*/ swap( a[ i ], a[ right - 1 ] ); // Restore pivot
/*11*/ quicksort( a, left, i - 1 ); // Sort small elements
/*12*/ quicksort( a, i + 1, right ); // Sort large elements
}
else // Do an insertion sort on the subarray
/*13*/ insertionSort( a, left, right );
}
/**
* Internal insertion sort routine for subarrays
* that is used by quicksort.
* a is an array of Comparable items.
* left is the left-most index of the subarray.
* right is the right-most index of the subarray.
*/
template <class Comparable>
void insertionSort( vector<Comparable> & a, int left, int right )
{
for( int p = left + 1; p <= right; p++ )
{
Comparable tmp = a[ p ];
int j;
for( j = p; j > left && tmp < a[ j - 1 ]; j-- )
a[ j ] = a[ j - 1 ];
a[ j ] = tmp;
}
}
/**
* Quick selection algorithm.
* Places the kth smallest item in a[k-1].
* a is an array of Comparable items.
* k is the desired rank (1 is minimum) in the entire array.
*/
template <class Comparable>
void quickSelect( vector<Comparable> & a, int k )
{
quickSelect( a, 0, a.size( ) - 1, k );
}
/**
* Internal selection method that makes recursive calls.
* Uses median-of-three partitioning and a cutoff of 10.
* Places the kth smallest item in a[k-1].
* a is an array of Comparable items.
* left is the left-most index of the subarray.
* right is the right-most index of the subarray.
* k is the desired rank (1 is minimum) in the entire array.
*/
template <class Comparable>
void quickSelect( vector<Comparable> & a, int left, int right, int k )
{
/* 1*/ if( left + 10 <= right )
{
/* 2*/ Comparable pivot = median3( a, left, right );
// Begin partitioning
/* 3*/ int i = left, j = right - 1;
/* 4*/ for( ; ; )
{
/* 5*/ while( a[ ++i ] < pivot ) { }
/* 6*/ while( pivot < a[ --j ] ) { }
/* 7*/ if( i < j )
/* 8*/ swap( a[ i ], a[ j ] );
else
/* 9*/ break;
}
/*10*/ swap( a[ i ], a[ right - 1 ] ); // Restore pivot
// Recurse; only this part changes
/*11*/ if( k <= i )
/*12*/ quickSelect( a, left, i - 1, k );
/*13*/ else if( k > i + 1 )
/*14*/ quickSelect( a, i + 1, right, k );
}
else // Do an insertion sort on the subarray
/*15*/ insertionSort( a, left, right );
}
/**
* Class that wraps a pointer variable.
*/
template <class Comparable>
class Pointer
{
public:
Pointer( Comparable *rhs = NULL ) : pointee( rhs ) { }
bool operator<( const Pointer & rhs ) const
{ return *pointee < *rhs.pointee; }
operator Comparable * ( ) const
{ return pointee; }
private:
Comparable *pointee;
};
/**
* Sort objects -- even large ones --
* with only N + ln N Comparable moves on average.
*/
template <class Comparable>
void largeObjectSort( vector<Comparable> & a )
{
vector<Pointer<Comparable> > p( a.size( ) );
int i, j, nextj;
for( i = 0; i < a.size( ); i++ )
p[ i ] = &a[ i ];
quicksort( p );
// Shuffle items in place
for( i = 0; i < a.size( ); i++ )
if( p[ i ] != &a[ i ] )
{
Comparable tmp = a[ i ];
for( j = i; p[ j ] != &a[ i ]; j = nextj )
{
nextj = p[ j ] - &a[ 0 ];
a[ j ] = *p[ j ];
p[ j ] = &a[ j ];
}
a[ j ] = tmp;
p[ j ] = &a[ j ];
}
}
#endif