void K_Merge::randomized_quicksort(_array_struct& arr, int start, int end) {
if (start < end) {
int q = randomized_partition(arr, start, end);
randomized_quicksort(arr, start, q-1);
randomized_quicksort(arr,q+1, end);
}
}
// main entry of quick sort routine
void randomized_quicksort(Aux A[], int p, int r) {
if (p < r) {
int q = randomized_partition(A, p, r);
randomized_quicksort(A, p, q-1);
randomized_quicksort(A, q+1, r);
}
}
static void
randomized_sort(int arr[], int left, int right) {
if (left < right) {
int mid = randomized_partition(arr, left, right);
randomized_sort(arr, left, mid-1);
randomized_sort(arr, mid+1, right);
}
}
void randomized_quick_sort(int *ap, int p, int r)
{
if (p < r) {
int q = randomized_partition(ap, p, r);
randomized_quick_sort(ap, p, q - 1);
randomized_quick_sort(ap, q + 1, r);
}
}
void randomized_quicksort(int *arr, int start, int end)
{
if(start >= end)
return;
int middle = randomized_partition(arr, start, end);
randomized_quicksort(arr, start, middle-1);
randomized_quicksort(arr, middle+1, end);
}
void randomized_quickSort(int* a, int p, int r)
{
if(p < r)
{
int q = randomized_partition(a, p, r);
quickSort(a, p, q - 1);
quickSort(a, q + 1, r);
}//end if(p < r)
}
void randomized_quicksort(Array &A, int p, int r){
if (p<r){ // se l'indice p e' minore dell'indice r
int q = randomized_partition(A, p, r);
randomized_quicksort(A,p,q-1); // chiamo la rand_quick su i due sottovettori
randomized_quicksort(A,q+1,r);
}
}
void quick_sort(int A[],int start,int end)
{
int p_index;
if (start >= end) {
return;
}
p_index = randomized_partition(A,start,end);
quick_sort(A,start,p_index - 1);
quick_sort(A,p_index + 1,end);
}
int randomized_select(int* arr, int s, int e, int i) {
if (s == e)
return arr[s];
int p = randomized_partition(arr, s, e);
int k = p-s+1; // +1 because, indexing starts at 0 while i starts at 1
if (k == i)
return arr[p];
else if (i < k)
return randomized_select(arr, s, p-1, i); // if it lies to the left, the required index is still i
else
return randomized_select(arr, p+1, e, i-k); // if it lies to the right, the required index is (i - k)
}
int randomized_select(int *arr, int start, int end, int i)
{
int randomized_partition(int*, int, int);
int partition = randomized_partition(arr, start, end);
int k = partition - start + 1;
if(k == i)
return arr[partition];
else
{
if(k < i)
return randomized_select(arr, partition+1, end, i-k);
else
return randomized_select(arr, start, partition-1, i);
}
}
int K_Merge::selection_i_th(int arr, int start, int end, int i) {
// selection in expected linear time
if ((arr >= _size) || (arr < 0))
arr = _size-1;
if (start == end)
return _array[arr]._data[start];
int q = randomized_partition(_array[arr], start, end);
int k = q-start+1;
if (i==k)
return _array[arr]._data[q];
else if (i < k)
return selection_i_th(arr, start, q-1, i);
else
return selection_i_th(arr, q+1, end, i-k);
}
double randomized_selection(double *Address, int start, int end, int position)
{
int random_position;
int temp_rank;
if (start==end)
return Address[start];
random_position=randomized_partition(Address,start,end);
temp_rank=random_position-start+1;
if (temp_rank>position+1)
return randomized_selection(Address,start,random_position-1,position);
else if (temp_rank<position+1)
return randomized_selection(Address,random_position+1,end,position-temp_rank);
else //if (pivot==position)
return Address[random_position];
}
double randomized_select(double *a, int p, int r, int i)
{
int q, k;
if (p == r)
return a[p];
q = randomized_partition(a, p, r);
/* number of elements in the first list */
k = q - p + 1;
if (i <= k)
return randomized_select(a, p, q, i);
else
return randomized_select(a, q+1, r, i-k);
}
