void quicksort(int a[],int left,int right){
if(right-left>2){
// printf("start1\n");
int mid=findpivot(a,left,right);
int i=left,j=right-1;
// printf("The pivot is: %d\n",mid);
while(1){
while(a[++i]<mid);
while(a[--j]>mid);
if(i<j){
// printf("swap: i:%d j:%d\n",i,j);
swap(&a[i],&a[j]);
}
else
break;
}
// printf("find: i:%d j:%d\n",i,j);
swap(&a[i],&a[right-1]);
// printf("sort1: %d %d\n",left,i-1);
quicksort(a,left,i-1);
// printf("sort2: %d %d\n",i+1,right);
quicksort(a,i+1,right);
} else{
bubble_sort(a+left,right-left+1);
}
}
int findpivot(int* arr, int low, int high)
{
if(low > high)
return -1;
if(high == low)
return low;
int mid = low + (high-low)/2;
if(mid < high && arr[mid] > arr[mid+1])
return mid+1;
if(arr[mid] <= arr[low])
return findpivot(arr, low, mid);
else
return findpivot(arr, mid, high);
}
void qsort(E array[], int i, int j) {
if ((j-i) <= THRESHOLD) return; // Don't sort short list
int pivotindex = findpivot(array, i, j);
swap(array, pivotindex, j); // stick pivot at end
int k = partition<E,Comp>(array, i-1, j, array[j]);
swap(array, k, j); // Put pivot value in place
qsort<E,Comp>(array, i, k-1);
qsort<E,Comp>(array, k+1, j);
}
/* *** ODSATag: Quicksort *** */
void quicksort(Comparable* A[], int i, int j) {
int pivotindex = findpivot(i, j);
swap(A, pivotindex, j); // Stick pivot at end
// k will be the first position in the right subarray
int k = partition(A, i, j-1,A[j]);
swap(A, k, j); // Put pivot in place
if ((k-i) > 1) quicksort(A, i, k-1); // Sort left partition
if ((j-k) > 1) quicksort(A, k+1, j); // Sort right partition
}
void quicksort(record_t* a, int n)
{
int pivotIndex;
double pivot;
if (findpivot(a, n, &pivot) != 0)
{
pivotIndex = partition(a, n, pivot);
quicksort(a, pivotIndex);
quicksort(a + pivotIndex, n - pivotIndex);
}
}
void quicksort(int arr[],int i,int j)
{
int pivotindex,k,pivot;
pivotindex=findpivot(arr,i,j);
if(pivotindex!-1)
{
pivot=arr[pivotindex];
k=partition(arr,i,j,pivot);
quicksort(arr,i,k-1);
quicksort(arr,k,j);
}
}
void sort(int *array, int* temp, int i, int j)
{
if(j-i < SORTHRESH) inssort(array, temp, i, j);
else
{
int pivotindex = findpivot(i, j);
swap(array+pivotindex, array+j);
swap(temp+pivotindex, temp+j);
int k = partition(array, temp, i-1, j, array[j]);
swap(array+k, array+j);
swap(temp+k, temp+j);
if((k-i)>1) sort(array, temp, i, k-1);
if((j-k)>1) sort(array, temp, k+1, j);
}
}
void SearchInSortedPivotedArr(int* arr, int low, int high, int x)
{
int pivot = findpivot(arr, low, high);
printf("\n pivot = %d\n", pivot);
if(pivot < 0)
{
printf("\n not sorted. Found x at %d\n", binsearch(arr, low, high, x));
return;
}
if(arr[pivot] == x)
{
printf("\n Found x at %d\n", pivot);
return;
}
if(arr[low] > x)
printf("\n found x at %d\n", binsearch(arr, pivot, high, x));
else
printf("\nFound x at %d\n", binsearch(arr, low, pivot-1, x));
}
