快速排序的几个变化形式

　　快速排序最简单的区间切分形式已经在前面的博文中介绍过了，是单向处理的，下面介绍快速排序的另几种形式，都是双向处理，即处理模式是，比Pivot小的往左移，比Pivot大的往右移，当两个方向相交后，把Pivot移动到相交位置往后的一个位置，最后形成三段，分别为比Pivot大，等于Pivot，大于Pivot。双向处理比单向处理的好处是，比Pivot大的元素一次移到右边后不需要再次移动，而单向处理里面，比Pivot大的元素则要不停的一次次往右移。

　　第一种：直接取最右边的元素为Pivot，此种切分方式代码如下：

int Partition1(int* pArr, int l, int r) {
    //此分割直接取最右边的元素作为pivot，所以在j的循环中，需要判断是否越界，因为一直到最左边可能没有比pivot小的元素，而不i不需要，因为最右边就是Pivot
    //找个分别比pivot小的和大的元素，然后交换位置,如果pivot是最大的，则不会交换任何元素(会交换最后一次，和本身)
    int i = l - 1;
    int j = r - 1;
    int pivot = pArr[r];
    while (true) {
        while (pArr[++i] < pivot) {}
        while (pArr[j] > pivot) {
            --j;
            if (j < l)
                break;
        }

        if (i >= j) //可以取=，表示指向了同一个位置，这时候无需交换值
            break;
        Swap(pArr + i, pArr + j);
    }
    Swap(pArr + j + 1, pArr + r);
    return j + 1;
}

　　第二种：随机化切分元素Pivot

　　第一种方式的问题是，如果数组是降序排好了的，那取最右边的元素就是最坏的选择,因为取到了最小的元素，最后算法一轮下来，只把自己移到最左边，其它元素都没有动。随机化选择Pivot，可以获得较好的平均期望性能，这里代码就不贴了，跟前面的一样，只是pivot是随机取的，然后将随机的数切换到最右边即可。这样做的前提是数组中所有元素出现的概率是等随机的

　　第三种：三取样切分的快速排序

　　意思是说取l，(l+r)/2，r的三个索引位置的元素，然后把最小的元素放左边，中间大的元素作为Pivot放在最右边，再对数组进行切分，之所以用中间大的元素，是因为这样可以获得平均期望性能。此外还可以按第一种形式，随机三个元素，然后再按这种方式排序后，再进行切分。

　　三取样这样做的好处，一是除了可以避免取到最坏的元素拿来做切分，二是还可以去掉第一二种情况里面的while循环的越界检查。代码如下：

void _Sort3(int* pArr, int l, int r) {
    if (r - l >= 2) {
        int m = _Partition3(pArr, l, r);
        _Sort3(pArr, l, m - 1);
        _Sort3(pArr, m, r);
    }
    else {
        if (pArr[l] > pArr[r])
            Swap(pArr + l, pArr + r);
    }
}

int Partition3(int* pArr, int l, int r)  {
    //此分割取左中右三个元素，然后取中间大的元素作为pivot，所以在j的循环中，无需判断j >= 0，因为到最左边一定有比pivot小的元素
    //如果是已经排好序的，则也不会交换任何元素，只会交换最后一次，和本身
    int m = (r + l) / 2;
    if (pArr[l] > pArr[r])
        Swap(pArr + l, pArr + r);
    if (pArr[r] > pArr[m])
        Swap(pArr + r, pArr + m);
    if (pArr[l] > pArr[r])
        Swap(pArr + l, pArr + r);

    int i = l;
    int j = r;
    int pivot = pArr[r];

    while (true) {
        //当i达到最右的r时，pArr[i]==pivot, while中断，不会越界
        while (pArr[++i] < pivot) {}

        //当j达到最左的l时，pArr[l]<pivot, while中断，不会越界
        while (pArr[--j] > pivot) {}

        if (i >= j)
            break;

        Swap(pArr + i, pArr + j);
    }
    Swap(pArr + (++j), pArr + r);
    return j;
}

　　第四种：三取向切分，针对大量重复元素的快速排序

　　直接取最右边元素为pivot，如果能取到最多的相同元素作为Pivot那最好了，可以最大限度的减少数据移动，代码如下：

void QuickSort(int* pArr, int l, int r) {
    if (r > l) {
        int i = l;
        int pivot = pArr[r];
        int low = l;
        int high = r;
        while (i <= high) {
            if (pArr[i] < pivot) {
                //这一步，除非下面的两个else有执行到，否则全部是跟自己本身在交换值
                Swap(pArr + (low++), pArr + i++);
                //比pivot小的元素，都往左边移,low只有在这时候才增加
            }
            else if (pArr[i] > pivot) {
                Swap(pArr + (high--), pArr + i);
                //比pivot大的元素，都往右边移,high只有在这时候才减小
            }
            else {
                ++i;
            }
        }
        QuickSort(pArr, l, low - 1);
        QuickSort(pArr, high + 1, r);
    }
}