#include <iostream>
#include <cstdlib>
#include <string.h> // for strcmp
#include <time.h>   // time
#include <vector>
#include <math.h>

using namespace std;

int moves;

const int MAXVALUE=1000000;
const int MAXDIGITS = 6;

void fillit(int array[], int arraysize) {
    int i;

    for(i=0;i<arraysize;i++) {
       array[i] = lrand48() % MAXVALUE;
    }
    return;
}

void CopyIt(int a[], int b[], int arraysize){
   int i;

   for(i=0;i<arraysize;i++) {
      b[i] = a[i];
   }
   return;
}

void PrintIt(int array[], int size) {
   int i;

   for(i=0;i<size;i++) {
      cout << array[i] << " ";
   }
   cout << endl;
}

bool IsInOrder(int array[], int arraysize) {
    bool inorder;
    int i;

    inorder = true;
    for(i=0;i<arraysize-1;i++) {
       if (array[i] > array[i+1]) {
           inorder = false;
       }
    }
    return(inorder);
}

void PrintAboutOrder(int array[],int arraysize){
    cout << "The array is " ;
    if (!IsInOrder(array,arraysize)) {
      cout << "NOT ";
    }
    cout << "in order." << endl;
    return;
}

void sort1(int array[], int arraysize) {
    int i, j, tmp;

    for(i=0;i<arraysize-1;i++) {
       for(j=i+1;j<arraysize;j++) {
          if(array[i] > array[j]) {
	      moves += 2;
	      tmp = array[i];
	      array[i] = array[j];
	      array[j] = tmp;
	  }
       }
    }
    return;
}

void sort2(int array[], int arraysize) {
    int i,j,tmp;
    int swppos;

    for(i=0;i<arraysize-1;i++) {
       swppos = i;
       for(j=i+1;j<arraysize;j++) {
          if(array[swppos] > array[j]) {
	      swppos = j;
	  }
       }
       if (swppos != i) {
           moves += 2;
           tmp = array[i];
           array[i] = array[swppos];
           array[swppos] = tmp;
       }
    }
    return;
}

void sort3(int array[], int arraysize) {
   int i,j,tmp;
   bool swapped=true;
   
   j = arraysize-1;
   while (swapped && (j > 0)) {
      swapped = false;
      for(i=0;i<j;i++) {
         if (array[i] > array[i+1]) {
	    moves += 2;
	    swapped = true;
	    tmp = array[i];
	    array[i] = array[i+1];
	    array[i+1] = tmp;
	 }
      }
      j--;
   }
   if (j > 1) {
     cout << "The third sort quit early!" << endl;
   }
}

void sort4a(int array[], int start, int stop, int & pivot) {
    int l,r;
    int tmp;
   
    l = start;
    r = stop-1;
    pivot =  stop;
    while (l <= r) {
       while ((l <= r) && (array[pivot] >= array[l])) {
         l ++;
       }
       while ((l <= r) && (array[pivot] <= array[r])) {
         r--;
       }
       if (l < r) {
           moves += 2;
          tmp = array[l];
	  array[l] = array[r];
	  array[r] = tmp;
       }
    }
    tmp = array[l];
    array[l] = array[pivot];
    array[pivot] = tmp;
    pivot = l;
    return;
}

void sort4b(int array[], int start, int end){
    int pivot;
    if(start < end) {
        sort4a(array, start,end,pivot);
	sort4b(array,start,pivot-1);
	sort4b(array,pivot+1,end);
    }
    return;
}

void sort4(int array[], int size) {
   sort4b(array,0,size-1);
}

void binSort(int array[], int size, int pos) {
    vector<int> bins[10];
    int i;
    int j;
    int val;

    vector<int>::iterator k;

    for(i=0;i<10;i++) {
        bins[i].clear();
    }

    val = int(pow(10.0,double(pos+1)));
    for(i=0;i<size;i++) { 
        moves += 1;
        j = (array[i]%val)/(val/10);
	bins[j].push_back(array[i]);
    }
    j = 0;
    for(i=0;i<10;i++) {   
       for(k=bins[i].begin();k!=bins[i].end();k++) { 
           moves += 1;
          array[j] = *k;
	  j++;
       }
    }
    return;
}

void radixSort(int array[], int size) {
   int pos;

   for(pos=0;pos<MAXDIGITS;pos++) {
       binSort(array,size,pos);
   }
   return;
}

void sort6(int array[], int size) {
    int i,j,tmp;

    for(i=1;i<size;i++) {
       j = i;
       tmp = array[j];
       while((j > 0) && (array[j-1] > tmp)) {
	   moves ++;
           array[j] = array[j-1];
	   j--;
       }
       array[j] = tmp;
       moves ++;
    }

    return;
}

void Heapify(int A[],int i,int size) {
    int l,r;
    int largest;
    int tmp;

    l = (i+1)*2-1;
    r = (i+1)*2;
    if ((l < size) && (A[l] > A[i])) {
        largest = l;
    } else {
        largest = i;
    }
    if ((r < size) && (A[r] > A[largest])) {
        largest = r;
    }
    if (largest != i) {
        moves += 2;
        tmp =  A[i];
	A[i] = A[largest];
	A[largest] = tmp;
	Heapify(A,largest,size);
    }
}

void BuildHeap(int array[], int size) {
   int i;

   for(i=(size-1)/2;i>=0;i--) {
       Heapify(array,i,size);
   }
}

void sort7(int array[], int size) {
    int i, tmp;

    BuildHeap(array,size);
    for(i=size-1;i>0;i--) {
         moves += 2;
         tmp = array[0];
	 array[0] = array[i];
	 array[i] = tmp;
	 Heapify(array,0,i);
    }
}

void Sort(int sort, int array[], int arraysize){
    int starttime, stoptime;
    int * sortarray;

    sortarray = new int[arraysize];

    CopyIt(array, sortarray, arraysize);

//    PrintAboutOrder(sortarray,arraysize);

    moves=0;
    starttime = time(NULL);
    switch (sort) {
      case 1: sort1(sortarray, arraysize); break;
      case 2: sort2(sortarray, arraysize); break;
      case 3: sort3(sortarray, arraysize); break;
      case 4: sort4(sortarray, arraysize); break;
      case 5: radixSort(sortarray, arraysize); break;
      case 6: sort6(sortarray, arraysize); break;
      case 7: sort7(sortarray, arraysize); break;
    }
    stoptime = time(NULL);

   if (!IsInOrder(sortarray,arraysize)) {
      cout << "OUT OF ORDER AFTER THE SORT" << endl;
   }

//   PrintAboutOrder(sortarray,arraysize);

    cout << "Sort" << sort << " took " ;
    cout << stoptime - starttime;
    cout <<" ticks, and ";
    cout << moves << " moves";
    cout << endl;
    delete sortarray;
    return;
}

int main (int argc, char * argv[]) {
    int i,j;
    int arraysize = 100000;
    int * array;
    bool doall = true;
    int mvs[5];

    for(i=1;i<argc;i++) {
       if (0 == strcmp(argv[i],"-4")){
          doall=false;
       }else if (0 == strcmp(argv[i],"-as")){
          i++;
          arraysize = atoi(argv[i]);
       } else {
          cout << "Unknown Argument " << argv[i] << endl;
       }
    }

    //srand48(time(NULL));
    for(i=0;i<5;i++) {
       mvs[i] =0;
    }

    for(j=0;j<10;j++) {
        array = new int[arraysize];
        fillit(array, arraysize);


        int s4m, s7m;
        if(doall) {
   //        Sort(1, array, arraysize);
   //        mvs[0] += moves;
   //        Sort(2, array, arraysize);
   //        mvs[1] += moves;
   //        Sort(3, array, arraysize);
   //        mvs[2] += moves;
           Sort(4, array, arraysize);
	   s4m = moves;
   //        mvs[3] += moves;
   //         Sort(5, array, arraysize);
   //        mvs[4] += moves;
   //          Sort(6,array,arraysize);
	     Sort(7, array, arraysize);
	     s7m = moves;

             cout << "Ratio: " << float(s7m)/ float(s4m) <<  endl;
        }
    }
   // for(i=0;i<5;i++) {
   //    cout << "sort " << i+1 << " averaged " <<mvs[i]/10 << " moves." <<endl;
   // }
    return(0);
}