Inconsistent output of quick sort

Question

I want to experience worst case of quick sort. Therefore, I generate an array with descending order. After sorting with quick sort, sometimes array's first element becomes a garbage and sometimes becomes 0 as expected. When first element is a garbage all elements' order slides up, second element becomes 0, third element becomes 1 etc. Here is my code:

void generateDescendingArray(int *arr, int n) {

    for(int i = n - 1; i >= 0; i--) {
       arr[n-i-1] = i;
    }
}

void quickSort(int *A, int start, int end) {
    if(end > start) {
       int s = partition(A, start, end); //split position
       quickSort(A, start, s - 1); //sort before the split
       quickSort(A, s + 1, end); //sort after the split
    }
}
int partition(int *A, int start, int end) {

    int pivot = A[start];
    int i = start;
    int j = end + 1;

    do {
    
        do { i++;
        } while(pivot > A[i]);
    
        do { j--;
        } while(pivot < A[j]);
    
        swap(&A[i], &A[j]);
    
    } while(j > i);
    swap(&A[i], &A[j]); //undo last swap when i >= j
    swap(&A[start], &A[j]);

    return j;
}
int main() {
   int A[n];
   generateDescendingArray(A, n);
   quickSort(A, 0, n);
   
   return 0;
}

Answer 1

As diagnosed in the comments, you need to:

• Prevent scanning on empty partitions by checking i and j before looping in partition() .
• Call quickSort() with the correct indexes — 0 and n-1 .

Experimentation suggests that the do { … } while (j > i); loop formulation also works cleanly.

Those changes lead to:

#include <stdio.h>

static inline void swap(int *a, int *b) { int t = *a; *a = *b; *b = t; }
static int partition(int *A, int start, int end);

static
void generateDescendingArray(int *arr, int n) {

    for(int i = n - 1; i >= 0; i--) {
       arr[n-i-1] = i;
    }
}

static
void quickSort(int *A, int start, int end) {
    if(end > start) {
       int s = partition(A, start, end); //split position
       quickSort(A, start, s - 1); //sort before the split
       quickSort(A, s + 1, end); //sort after the split
    }
}

static
int partition(int *A, int start, int end) {

    int pivot = A[start];
    int i = start;
    int j = end + 1;

    while (i < j)
    {

        do { i++;
        } while(pivot > A[i]);

        do { j--;
        } while(pivot < A[j]);

        swap(&A[i], &A[j]);

    }
    swap(&A[i], &A[j]); //undo last swap when i >= j
    swap(&A[start], &A[j]);

    return j;
}

enum { NUM_PER_LINE = 10 };

static void print_data(const char *tag, const int *A, int num)
{
    printf("%s (%d):\n", tag, num);
    const char *pad = "";
    int i;
    for (i = 0; i < num; i++)
    {
        printf("%s%d", pad, A[i]);
        pad = " ";
        if (i % NUM_PER_LINE == NUM_PER_LINE - 1)
        {
            putchar('\n');
            pad = "";
        }
    }
    if (i % NUM_PER_LINE != 0)
        putchar('\n');
}

int main(void) {
   for (int n = 1; n < 24; n++)
   {
       int A[n];
       generateDescendingArray(A, n);
       print_data("Unsorted", A, n);
       quickSort(A, 0, n-1);
       print_data("Sorted", A, n);
   }

   return 0;
}

The code produces the correct output, AFAICS:

Unsorted (1):
0
Sorted (1):
0
Unsorted (2):
1 0
Sorted (2):
0 1
Unsorted (3):
2 1 0
Sorted (3):
0 1 2
Unsorted (4):
3 2 1 0
Sorted (4):
0 1 2 3
…
Unsorted (21):
20 19 18 17 16 15 14 13 12 11
10 9 8 7 6 5 4 3 2 1
0
Sorted (21):
0 1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19
20
Unsorted (22):
21 20 19 18 17 16 15 14 13 12
11 10 9 8 7 6 5 4 3 2
1 0
Sorted (22):
0 1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19
20 21
Unsorted (23):
22 21 20 19 18 17 16 15 14 13
12 11 10 9 8 7 6 5 4 3
2 1 0
Sorted (23):
0 1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19
20 21 22

Answer 2

Using Hoare's partition scheme:

int partition(int *A, int start, int end) {

   int i = start - 1;
   int j = end + 1;
   int pivot = start;

   while(1) {
      while (A[++i] < A[pivot]);
      while (A[--j] > A[pivot]);

      if (i >= j) {
        return j;
      }
      // swap A[i] and A[j]
  }

  return j;
}

void quickSort(int *A, int start, int end) {
    if(start < end) {
       int s = partition(A, start, end);
       quickSort(A, start, s);
       quickSort(A, s + 1, end);
    }
 }

int main() {
    ...  
    quickSort(A, 0, n - 1); // CHANGED to n - 1 because you already have + 1 in partition
}