kth smallest number using variation of quicksort - c

Question

I have the following partition method and kthsmallest method (Variation of quicksort) which works for some cases but gives me the value 32767 for a few cases.
void swap(int* a, int* b){
int temp = *b;
*b = *a;
*a = temp;
}
int partition(int* arr, int l, int r){
int pivot = arr[r];
int i = l, j=0;
for(j=l; j<=r-1; j++){
if(arr[j] <= pivot){
swap(&arr[i], &arr[j]);
i++;
}
}
swap(&arr[i], &arr[j]);
return i;
}
And the kthsmallest function is as follows:-
int kthsmallest(int* arr, int low, int high, int k){
/* low = 0 and high = #elements - 1 */
/* k is in between 1 to high + 1 */
if (k>0 & k<=high-low+1) {
// pos is partitioning index, arr[p] is now at right place
int pos = partition(arr, low, high);
// Separately sort elements before / partition and after partition
if(pos-low == k-1){
return arr[pos];
}
//if position returned is greater than k, recurse left subarray
else if(pos-low > k-1){
return kthsmallest(arr, low, pos-1, k);
}
return kthsmallest(arr, pos+1, high, k-(pos+1));
}
}
However it works when I change the last call in kthsmallest function i.e.
Change: return kthsmallest(arr, pos+1, high, k-(pos+1));
To: return kthsmallest(arr, pos+1, high, k-(pos+1)+low);
I want to understand why I need to add low to k-(pos+1). Because in my view, when we have the subarray on the right in which the recursion enters, the kth smallest number in the large array boils down to k - last partition element -1 i.e. k-(pos+1).

Answer 1

You need low because when you recursively start with a new array, low will be the reference for pos. So the new k will be calculated from low to pos.
Maybe an example would be more clarifying.
Lets find the 9th smallest element of this array:
Now we do the partition, so we get:
From pos to the left we've got the smallest elements in the array, that's the 3 smallest elements. Now we'll work with the subarray starting from pos+1. And we need to get the 6th smallest element:
We do a partition over this subarray:
Remember that we are working over a subarray trying to find the 6th smallest element. In this case we separated the (pos - low + 1)th smallest elements in the subarray. So our new k will be:
We do a new partition:
Now we exceeded the 4th smallest element of the last subarray, so we trim the last part:
We do the partition again:
And we get:
So our number is 17.
Hope it helps.
PD: As David C. Rankin says in comments you probably should change & for &&.

Answer 2

It appears one of the problems you are having is trying to shoehorn a quickselect routine into a recursive function when there is no reason to make the function recursive to begin with. All you need to do is identify the partition the 'k' element resides in, there is no need to sort. All you need for your kthsmallest is:
/** select the ZERO BASED 'k' element from 'arr'.
* where 'low' and 'high' are the ZERO BASED low
* and high indexes for 'arr'.
*/
int kthsmallest (int *arr, int low, int high, int k)
{
for (;;) {
if (low == high)
return arr[low];
int pos = partition (arr, low, high);
if (k == pos)
return arr[k];
else if (k < pos)
high = pos - 1;
else
low = pos + 1;
}
}
Using your exact partition and swap functions, you can write a small example program to test k for every element in an array. (note: the element returned is based on a zero indexed k, e.g. the first smallest element is offset zero from the end of the array -- just like in the rest of C)
#include <stdio.h>
void swap (int *a, int *b);
int partition (int *arr, int l, int r);
/** select the ZERO BASED 'k' element from 'arr'.
* where 'low' and 'high' are the ZERO BASED low
* and high indexes for 'arr'.
*/
int kthsmallest (int *arr, int low, int high, int k)
{
for (;;) {
if (low == high)
return arr[low];
int pos = partition (arr, low, high);
if (k == pos)
return arr[k];
else if (k < pos)
high = pos - 1;
else
low = pos + 1;
}
}
int main (void) {
int a[] = { 51, 86, 34, 79, 92, 68, 14, 47, 22, 6 },
nelem = sizeof a / sizeof *a;
for (int i = 0; i < nelem; i++)
printf (" nth (%2d) element is : %d\n", i,
kthsmallest (a, 0, nelem - 1, i));
return 0;
}
void swap (int *a, int *b)
{
int temp = *b;
*b = *a;
*a = temp;
}
int partition (int *arr, int l, int r)
{
int pivot = arr[r];
int i = l, j = 0;
for (j = l; j <= r - 1; j++) {
if (arr[j] <= pivot) {
swap (&arr[i], &arr[j]);
i++;
}
}
swap (&arr[i], &arr[j]);
return i;
}
Example Use/Output
$ ./bin/kthsmall
nth ( 0) element is : 6
nth ( 1) element is : 14
nth ( 2) element is : 22
nth ( 3) element is : 34
nth ( 4) element is : 47
nth ( 5) element is : 51
nth ( 6) element is : 68
nth ( 7) element is : 79
nth ( 8) element is : 86
nth ( 9) element is : 92