算法描述： 快速排序一般是选择数组的第一个数据为对称轴参考值pivot。按照大小数组分割成左右两个区间。然后对左右两个区间再进行递归排序，知道结束为止。

例子演示：

数组：4 3 2 5 1，长度：5，对称轴参考值选择第一个数据4。比它小的我们放到它的右边，比它大的我们放到左边。设置左右两个工作位置。指向开头和末尾。

第一轮：

• 4 3 2 5 1→4 3 2 5 1 开始右边的工作，比较最后一位1是否比4大，否，不复制
• 4 3 2 5 1→5 3 2 5 1 移动右边的工作位置到左一位，比较5是否比4大，是，复制5到左边工作位置上
• 5 3 2 5 1→5 3 2 5 1 切换工作工作位置到左边，比较5是否比4小，否，不复制
• 5 3 2 5 1→5 3 2 3 1 移动左边工作位置到右边一位，比较3是否比4小，是，交换到右边工作位置上
• 5 3 2 3 1→5 3 2 3 1 切换工作方向到右边，比较2是否大于4，否，不用复制
• 5 3 2 3 1→5 4 2 3 1 左右工作结束，把对称轴参考值复制到左边工作位置最后的位置上

第二轮

• 5→5  计算过程仿照第一轮。计算对称轴左边的区间，只有一个数字，完成。
• 2 3 1 → 3 2 1 计算过程仿照第一轮。计算对称轴右边的区间，把2选为对称轴参考值

总结：快速排序算法优点：运算快，操作少，相同的数据长度，只进行了两轮运算。缺点：逻辑复杂，需要处理两个工作方向，有递归。运算不稳定，左右区间可能长度不对称。

#include <iostream>

void quickSort(int *array, int left, int right)
{
    if (left < right)
    {
        int pivot = array[left];
        int leftWorkPos = left;
        int rightWorkPos = right;
        while (leftWorkPos < rightWorkPos)
        {
            while (leftWorkPos < rightWorkPos && array[rightWorkPos] <= pivot)
            {
                rightWorkPos--;
            }
            array[leftWorkPos] = array[rightWorkPos];
            while (leftWorkPos < rightWorkPos && array[leftWorkPos] >= pivot)
            {
                leftWorkPos++;
            }
            array[rightWorkPos] = array[leftWorkPos];    
        }
        array[leftWorkPos] = pivot;
        quickSort(array, left, leftWorkPos - 1);
        quickSort(array, leftWorkPos + 1, right);
    }
}

int main()
{
    int array[] = {1, 7, 9, 2, 4};
    printf("array before quick sort=");
    int i = 0;
    for (i = 0; i < sizeof(array)/sizeof(array[0]); i++)
    {
        printf("%d ", array[i]);
    }
    printf("\n");
    quickSort(array, 0, sizeof(array)/sizeof(array[0]) - 1);
    printf("array after  quick sort=");
    for (i = 0; i < sizeof(array)/sizeof(array[0]); i++)
    {
        printf("%d ", array[i]);
    }
    return 0;
}