int main( int argc, char *argv[] ) {
if ( argc != 4 ) {
cout
<< "Wrong number of command-line arguments" << endl
<< "Usage: method2 starting-power-of-2 ending-power-of-2 repetitions" << endl
<< "Example: method2 4 10 50000" << endl;
return 1;
}
Timer aTimer1, aTimer2;
const char * pattern = "target";
long int N = atoi( argv[ 1 ] );
N = ( long int ) pow( 2, N );
long int OUTERLIMIT = atoi( argv[ 2 ] );
OUTERLIMIT = ( long int ) pow( 2, OUTERLIMIT );
long int INNERLIMIT = atoi( argv[ 3 ] );
long double elapsedCPUtime = 0;
long int pos = 0;
cout
<< endl
<< "Timing results are expressed in seconds" << endl
<< "Resolution of the clock: " << aTimer1.getResolution() << " seconds" << endl
<< "Starting N: " << N << endl
<< "Maximum N: " << OUTERLIMIT << endl
<< "Repetitions for each N: " << INNERLIMIT << endl
<< endl
<< setw( 9 ) << "N"
<< setw( 14 ) << "T (seconds)"
<< setw( 14 ) << "T / logN"
<< setw( 14 ) << "T / N"
<< setw( 14 ) << "T / NlogN"
<< setw( 14 ) << "T / N^2"
<< endl
<< setfill( '-' ) << setw( 14 * 5 + 9 ) << "" << setfill( ' ' )
<< endl;
while ( N <= OUTERLIMIT ) {
// edited by Mark Randles
vector<int> vi;
for (int i = 0; i < N; i++)
vi.push_back( i );
random_shuffle(vi.begin(), vi.end());
aTimer1.start(); // Time "empty" function
for ( long int j = 0; j < INNERLIMIT; j++ )
pos = flashsortTest( vi.begin(), vi.end() ); // edited by Mark Randles
aTimer1.stop();
// aTimer1.display( "aTimer1 after stop()" );
// edited by Mark Randles
for (int i = 0; i < N; i++)
vi.push_back( i );
random_shuffle(vi.begin(), vi.end());
aTimer2.start(); // Time the real function
for ( long int j = 0; j < INNERLIMIT; j++ )
pos = flashsort( vi.begin(), vi.end() ); // edited by Mark Randles
aTimer2.stop();
// aTimer2.display( "aTimer2 after stop()" );
// Next line requires overload of operator-
if ( aTimer1 > aTimer2 )
cout << "Invalid data for N = " << N << endl;
else {
elapsedCPUtime = ( aTimer2 - aTimer1 ) / INNERLIMIT;
printLine( N, elapsedCPUtime );
}
N += N;
aTimer1.clear();
aTimer2.clear();
}
return 0;
}
void flashsort(RandomAccessIterator begin, RandomAccessIterator end) {
typedef iterator_traits< RandomAccessIterator >::value_type T;
if(begin == end) return;
int length = end - begin;
int m = (int)((0.2 * length) + 2);
T min, max, maxIndex;
min = max = *begin;
maxIndex = 0;
for(int i = 1; i < length - 1; i += 2) {
T small, big, bigIndex;
if(*(begin+i) < *(begin+i+1)) {
small = *(begin+i);
big = *(begin+i+1);
bigIndex = i+1;
} else {
big = *(begin+i);
bigIndex = i;
small = *(begin+i+1);
}
if(big > max) {
max = big;
maxIndex = bigIndex;
}
if(small < min) min = small;
}
if(*(begin+length-1) < min) {
min = *(begin+length-1);
}
else if(*(begin+length-1) > max) {
max = *(begin+length-1);
maxIndex = length-1;
}
if(max == min) return;
T* L = new T[m+1];
for(int t = 1; t <= m; t++) L[t] = 0;
double c = (m-1.0)/(max-min);
int K;
for(RandomAccessIterator h=begin; h != end; ++h) {
K = ((int)(((*h)-min)*c))+1;
L[K] += 1;
}
for(K = 2; K <= m; K++) {
L[K] = L[K] + L[K-1];
}
T temp = *(begin+maxIndex);
*(begin+maxIndex) = *begin;
*begin = temp;
int j = 0;
K = m;
int numMoves = 0;
while(numMoves < length) {
while(j >= L[K]) {
j++;
K = ((int)((*(begin+j) - min) * c)) + 1;
}
T evicted = *(begin+j);
while(j < L[K]) {
K = ((int)((evicted-min)*c))+1;
int location = L[K] - 1;
T temp = *(begin+location);
*(begin+location) = evicted;
evicted = temp;
L[K] -= 1;
numMoves++;
}
}
int threshold = (int)(1.25*((length/m)+1));
const int minElements = 30;
for(K = m - 1; K >= 1; K--) {
int classSize = L[K+1] - L[K];
if(classSize > threshold && classSize > minElements) {
flashsort(begin+L[K],begin+L[K]+classSize);
} else {
if(classSize > 1) {
isort5(begin+L[K],begin+L[K]+classSize);
}
}
}
delete [] L;
}
void flashsort(float a[], int n, int m, int * ctr){
/* declare variables */
int * l, nmin, nmax, i, j, k, nmove, nx, mx;
float c1, c2, flash, hold;
/* allocate space for the l vector */
l = (int*)calloc(m, sizeof(int));
/***** CLASS FORMATION ****/
nmin = nmax = 0;
for(i=0 ; i < n ; i++){
if (a[i] < a[nmin])
nmin = i;
else if (a[i] > a[nmax])
nmax = i;
}
if((a[nmax]==a[nmin]) && (ctr==0)){
printf("All the numbers are identical, the list is sorted\n");
return;
}
c1=(m-1.0)/(a[nmax]-a[nmin]);
c2=a[nmin];
l[0] = -1; /* since the base of the "a" (data) array is 0 */
for(k=1; k < m ; k++)
l[k] = 0;
for (i=0; i < n ; i++){
k = floor(c1*(a[i]-c2) );
l[k] += 1;
}
for (k=1; k < m ; k++)
l[k] += l[k-1];
hold = a[nmax];
a[nmax] = a[0];
a[0] = hold;
/**** PERMUTATION *****/
nmove = 0;
j = 0;
k = m-1;
while(nmove < n){
while(j > l[k]){
j++;
k = floor(c1*(a[j]-c2));
}
flash=a[ j ] ;
while(j <= l[k]){
k = floor(c1*(flash-c2));
hold = a[ l[k] ];
a[ l[k] ] = flash;
l[k]--;
flash = hold;
nmove++;
}
}
/**** Choice of RECURSION or STRAIGHT INSERTION *****/
for (k=0;k<(m-1);k++)
if ( (nx = l[k+1]-l[k]) > THRESHOLD ) /* then use recursion */
{
flashsort(&a[l[k]+1],nx,CLASS_SIZE,ctr);
(*ctr)++;
}
else /* use insertion sort */
for (i=l[k+1]-1; i > l[k] ; i--)
if (a[i] > a[i+1]){
hold = a[i];
j = i;
while(hold > a[j+1])
a[j++] = a[j+1];
a[j] = hold,
}
