Quicksort in C++

/*
The PARTITION procedure is the key to the QUICKSORT algorithm, it rearranges
the subarray A[p...r] in place. PARTITION always selects an element A[r] as a
pivot element around which to partition the subarray A[p...r].
As the procedure runs, the array is partitioned into four (possibly empty)
regions: the values in A[p...i] are all less than or equal to the pivot, the
values in A[(i+1)...(j-1)] are all greater than the pivot, the values in
A[j...(r-1)] can take on any values, and the pivot A[r].
*/
int partition(int A[], int p, int r) {
    int pivot = A[r];
    int i = p - 1;
   
    for (int j = p; j < r; ++j) {
        if (A[j] <= pivot) {
            ++i;
            exchange(&A[i], &A[j]);
        }
    }
       
    exchange(&A[i + 1], &A[r]);
   
    return i + 1;
}

/*
Quicksort, like merge sort, is based on the divide-and-conquer paradigm.
Here is the three-step divide-and-conquer process for sorting a typical
subarray A[p...r]:
Divide: Partition (rearrange) the array A[p...r] into two (possibly empty)
subarrays A[p...(q-1)] and A[(q+1)...r] such that each element of A[p...(q-1)]
is less than or equal to A[q], which is, in turn, less than or equal to each
element of A[(q+1)...r]. Compute the index q as part of this partitioning
procedure.
Conquer: Sort the two subarrays A[p...(q-1)] and A[(q+1)...r] by recursive
calls to quicksort.
Combine: Since the subarrays are sorted in place, no work is needed to combine
them, the entire array A[p...r] is now sorted.
*/
void quicksort(int A[], int p, int r) {
    if (p >= r) return;
   
    int q = partition(A, p, r);
    quicksort(A, p, q - 1);
    quicksort(A, q + 1, r);
}