编辑代码

#include <iostream>
#include <math.h>
#include <cstdlib>

using namespace std;
//快速排序的核心思想就是从数组中任选一个数据，然后找到这个数据在数组排序后的位置，
// 并且把比这个数小的数据放在这个位置的左边，把比这个数大的数据都放在这个位置的右边
// 然后分别对左右两边的数组采用同样的方式排序直至所有分成的两部分的数据元素为1，就都排好序了

// partition就是要找出选择的这个数据在数组排序后的位置并且把比它小的数据放在这个位置左边，比这个数据大的放在这个位置的右边

// array 要排序的完整的数组
// arrStart 当前要排序的子数组的起始位置的下标 
// arrEnd 当前要排序的子数组的终止位置下标+1
// pivotPos 用来分区的基准值的位置
// 返回值就是基准值经过排序后在数组中的位置的下标

int partition(int array[], int arrStart, int pivotPos, int arrEnd) {
   int arrayLen = arrEnd - arrStart;

//    if ( arrayLen < 1 || pivotPos < arrStart || pivotPos >= arrEnd) {
//        cout << "Please check your implementation." << endl;
//        return -1;
//    }
   int pivotValue = array[pivotPos];
   array[pivotPos] = array[arrEnd - 1];
   int i = 0; // 表示比基准值小的数据的个数，arrStart + i 表示当前比基准值小的数据准备放入位置的下标
   int temp;

  // 把遍历到的比基准值小的数据从左到右放置，这样，所有比基准值小的数据都在左边，同时也找到基准值在排序后的位置
   for (int j = arrStart; j < arrEnd - 1; ++j)
   {
       if (array[j] < pivotValue) {
          temp = array[arrStart + i];
          array[arrStart + i] = array[j];
          array[j] = temp;
          ++i;
       }
   }

   // 比基准值小的数据都在arrStart+i之前，所以arrStart+i肯定比基准值大，把它放最右边，也就是最后
   array[arrEnd - 1] = array[arrStart + i];
   // arrStart+i就是基准值所在位置
   array[arrStart + i] = pivotValue;

   // 基准值在数组中的位置
   return arrStart + i;
}
bool quickSort(int array[], int arrStart, int arrEnd) {
    int arrLen = arrEnd - arrStart;
    // if (arrLen < 0) {
    //     cout << "Please check your input." << endl;
    //     return false;
    // }

    // 终止条件
    if (arrLen == 0 || arrLen == 1) {
        return true;
    } 
    // 找一个基准值的位置
    // 找一个随机数，这个随机数就在arrStart到arrEnd之间
    srand(array[arrStart] + arrLen + array[arrEnd - 1]);
    int pivotPos = arrStart + floor(((arrLen - 1) + (size_t)rand()) % (arrLen - 1));

    int pivotOrderedPos = partition(array, arrStart, pivotPos, arrEnd);

    quickSort(array, arrStart, pivotOrderedPos);
    quickSort(array, pivotPosOrdered+1, arrEnd);

    return true;
}

void printArray(int array[], int arrLen) {
    for (int i = 0; i < arrLen; ++i) {
        cout << array[i] << " ";
    }
    cout << endl;
}

int main(){
    int array0[] = {};
    int arrayLen = sizeof(array0)/sizeof(int);

    printArray(array0, arrayLen);
    quickSort(array0, 0, arrayLen);
    printArray(array0, arrayLen);

    cout << "=========================================" << endl;

    int array1[] = {1};
    arrayLen = sizeof(array1)/sizeof(int);

    printArray(array1, arrayLen);
    quickSort(array1, 0, arrayLen);
    printArray(array1, arrayLen);

    cout << "=========================================" << endl;

    int array2[] = {2, 1};
    arrayLen = sizeof(array2)/sizeof(int);

    printArray(array2, arrayLen);
    quickSort(array2, 0, arrayLen);
    printArray(array2, arrayLen);

    cout << "=========================================" << endl;

    int array3[] = {1, 5, 3};
    arrayLen = sizeof(array3)/sizeof(int);

    printArray(array3, arrayLen);
    quickSort(array3, 0, arrayLen);
    printArray(array3, arrayLen);


    cout << "=========================================" << endl;

    int array4[] = {9, 12, 8, 7};
    arrayLen = sizeof(array4)/sizeof(int);

    printArray(array4, arrayLen);
    quickSort(array4, 0, arrayLen);
    printArray(array4, arrayLen);

    cout << "=========================================" << endl;

    int array5[] = {9, 12, 8, 7, 3};
    arrayLen = sizeof(array5)/sizeof(int);

    printArray(array5, arrayLen);
    quickSort(array5, 0, arrayLen);
    printArray(array5, arrayLen);


}