Question

I’m trying to use quick sort for my project but it doesn’t work. And I can’t figure out where the bug is. Anyone who can help me figure it out? Thank you.

void quicksort(int arr[],int a, int b){
    if(a<=b){
        int key=arr[a];
        int index=a;
        int i=a, j=b;
        while(i<=j){
            for(;arr[j]>key;--j);
            int temp=arr[j];
            arr[j]=key;
            arr[index]=temp;
            index=j;
            for(;arr[i]<key;++i);
            temp=arr[i];
            arr[i]=key;
            arr[index]=temp;
            index=i;
            }
        quicksort(arr,a,index);
        quicksort(arr,index,b);
        }
    else return;
} 

Answer 1

Your inner loop does this:

• Check from the right-hand-side of the array to find an element that should be on the left side of key.
• Swap any found element with key, located at index and update index to key‘s new location
• Check from the left-hand-side of the array to find an element that should be on the right side of key.
• Swap any found element with key, located at index and update index to key‘s new location

Why in the world would you want to do this? You should do this:

• Check from the right-hand-side of the array to find an element that should be on the left side of key.
• Check from the left-hand-side of the array to find an element that should be on the right side of key.
• If found, swap them. If not, put the pivot in the right position and exit loop

I’m not 100% sure, but I think that shuffling the key around in your version of quicksort may be the culprit of your problem. The best way to find out is to debug your code step by step and see where it goes wrong.

Here’s the implementation according to my suggestion above, together with a few test-cases:

void swap(int arr[], int i, int j) {
    int temp = arr[j];
    arr[j] = arr[i];
    arr[i] = temp;
}

void quicksort0(int arr[], int a, int b) {
    if (a >= b)
        return;

    int key = arr[a];
    int i = a + 1, j = b;
    while (i < j) {
        while (i < j && arr[j] >= key)
            --j;
        while (i < j && arr[i] <= key)
            ++i;
        if (i < j)
            swap(arr, i, j);
    }
    if (arr[a] > arr[i]) {
        swap(arr, a, i);
        quicksort0(arr, a, i - 1);
        quicksort0(arr, i + 1, b);
    } else { // there is no left-hand-side
        quicksort0(arr, a + 1, b);
    }
}

void quicksort(int arr[], int len) {
    quicksort0(arr, 0, len - 1);
}

int main() {
    int a1[] = { };
    int a2[] = { 1 };
    int a3[] = { 1, 1 };
    int a4[] = { 1, 2, 3, 4, 5 };
    int a5[] = { 5, 4, 3, 2, 1 };
    int a6[] = { 9, 2, 6, 7, 5, 4, 0, 2, 7, 5 };

    quicksort(a1, 0);
    quicksort(a2, 1);
    quicksort(a3, 2);
    quicksort(a4, 5);
    quicksort(a5, 5);
    quicksort(a6, 10);
    quicksort(a6, 10);
}