1. 思想

step1. 从数列中挑出一个元素，称为 “基准”（pivot）。

step2. 分区（partition）：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。

step3. 递归地（recursive）把基准值左边的子数列和右边的子数列排序。

1.1 具体实现

step1. 以最左边为基准值，将a[low]作为pivot
step2. j值开始是low+1，i从j开始循环，将j指向当前第一个比pivot大的值，如果发现数组中有一个比pivot小，就将a[i]与a[j]替换
step3. 循环结束，此时a[low]是pivot，a[low+1]到a[j-1]的值都小于pivot，j右边的值都大于pivot。将a[low]与a[j-1]互换

        void swap(int& a, int& b)
        {
    
    
            int t = a;
            a = b;
            b = t;
        }

        int partition(int arr[], int low, int high)
        {
    
    
            int pivot = arr[low]; // pivot
            int j = low+1; // Index of smaller element and indicates the right position of pivot found so far

            for (int i = j; i <= high; i++)
            {
    
    
                // If current element is smaller than the pivot
                if (arr[i] < pivot)
                {
    
    
                    swap(arr[j], arr[i]);
                    j++; // increment index of smaller element
                }
            }
            swap(arr[j-1], arr[low]);
            return (j-1);
        }
       
        void quickSort(int A[], int low, int high) //快排母函数
        {
    
    
            if (low < high) {
    
    
                int pivot = partition(A, low, high);
                quickSort(A, low, pivot - 1);
                quickSort(A, pivot + 1, high);
            }
        }
        
        void test() {
    
     
	        int a[] = {
    
     1, 4, 5, 2, 10, 8 };
	        int nSize = sizeof(a) / sizeof(int);
	        quickSort(a, 0, nSize-1);
        }

eg.

数组： 4 2 5 3 10 
pivot: 4


开始：
4 2 5 3 10
  j
   
->
4 2 5 3 10
    j      
->
4 2 3 5 10
      j
         
循环结束：再将a[low] 与a[j-1]互换->
3 2 4 5 10

[1] 代码quickSort.h