void quicksort(int A[], int p, int r) {
if (p<r-1) {
int q=hoare_partition(A,p,r);
quicksort(A,p,q+1);
quicksort(A,q+1,r);
}
}
static void
hoare_qsort(int arr[], int left, int right) {
if (left < right) {
int mid = hoare_partition(arr, left, right);
hoare_qsort(arr, left, mid); /* Hoare partition scheme */
hoare_qsort(arr, mid+1, right);
}
}
void quicksort(int p, int r){
int q;
if(p < r){
q = hoare_partition(p,r);
quicksort(p,q);
quicksort(q+1,r);
}
}
void hoare_quickSort(int *a, int p, int r)
{
if(p < r)
{
int q = hoare_partition(a, p, r);
printf("%d,%d,%d\n", p, q, r);
sleep(1);
hoare_quickSort(a, p, q);
hoare_quickSort(a, q + 1, r);
}
}
int select(int *Array,int p,int q,int i) //return the i min element in Array
{
if((p+1) == i)
return Array[p];
int pos = hoare_partition(Array,p,q);
if((pos+1) == i)
return Array[pos];
else if((pos+1) < i)
return select(Array,pos+1,q,i-pos-1);
else
return select(Array,p,pos-1,i);
}
static void quick_sort_h(register int a[], register int left, register int right) {
//if array is empty or only 1 element sort is redudant
if (left < right && !is_sorted(a, left, right)) {
if ((right - left) < THRESHOLD) {
insertion_sort_sub(a, left, right + 1);
return;
}
//get the pivot index
register int pivot_index = hoare_partition(a, left, right);
//recursively run the sort again with half-left and half-right of the array
quick_sort_h(a, left, pivot_index - 1);
quick_sort_h(a, pivot_index + 1, right);
}
}
void _quicksort(std::vector<T>& arr, const int64_t lo, const int64_t hi) {
#if 0
if (lo < hi) {
int64_t mid = lomuto_partition(arr, lo, hi);
_quicksort(arr, lo, mid-1);
_quicksort(arr, mid+1, hi);
}
#else
if (lo < hi) {
int64_t mid = hoare_partition(arr, lo, hi);
_quicksort(arr, lo, mid);
_quicksort(arr, mid+1, hi);
}
#endif
}
