DualPivotQuicksort两枢轴快速排序

参考jdk DualQuickSort源码
普通快速排序一次把数据划分成两部分，两部分再分别递归，两枢轴，就是两个结点，把数据划分成三部分，三部分再分别递归，可参考下图

            left part           center part                   right part          +--------------------------------------------------------------+          |  < pivot1   |    pivot1 <= && <= pivot2      |    > pivot2  |          +--------------------------------------------------------------+                        ^                                ^                        |                                |                       less                            great

划分成三部分：leftpart：x<p1，centerpart：p1<=x<=p2，rightpart:x>p2

注意：p1< p2
如何完成这个操作
程序中给的下图

        /*         * Partitioning:         *         *   left part           center part                   right part         * +--------------------------------------------------------------+         * |  < pivot1  |  pivot1 <= && <= pivot2  |    ?    |  > pivot2  |         * +--------------------------------------------------------------+         *               ^                          ^       ^         *               |                          |       |         *              less                        k     great         *         * Invariants:         *         *              all in (left, less)   < pivot1         *    pivot1 <= all in [less, k)     <= pivot2         *              all in (great, right) > pivot2         *         * Pointer k is the first index of ?-part.         */

less指向 < p1 的下一个位置
great指向 > p2 的前一个位置
k 是遍历的当前位置
less 到 k -1 之间的数：p1 <= x <= p2
对变量的当前k位置出现下面三种情况：
（1）ak < p1 交换 k 和less位置的数，less++
（2）ak < p1 && ak >p2 这个时候需要将 ak这个数放到对应的great的位置
程序中是先找到：A[great] < pivot2 的位置

while (A[great] > pivot2) { // 找到不满足条件的位置                      if (great-- == k) {                         System.out.println("outer");                         break outer;                     }                 }

再判断：A[great] < pivot1
若成立：这个时候说明great位置的数应该在 在< p1 的部分

                if (A[great] < pivot1) { // a[great] <= pivot1，                       A[k] = A[less];  // less放到 k的位置,  k 位置的元素数保存在 ak中                       A[less] = A[great]; // great 放到less的位置                      ++less;  // 更新 less                  } else { // pivot1 <= a[great] <= pivot2                     A[k] = A[great];                 }

最后还有这个

A[great] = ak; // ak 放到 great位置 --great;

上面的过程看着比较复杂，其实就是一个交换数的过程
若：A[great] < pivot1
A[less]位置说应该在中间部分，这里可以放到k的位置
A[great]应该放到less位置
又：ak这个数放到对应的great的位置
最后上面程序已经有了
若：A[great] >= pivot1 又：A[great] <= pivot2

A[k] = A[great];

A[great] = ak

就这样

结束后：形成最上面的形式，三个部分再分别进行递归
在jdk1.7中DualQuickSort 进行了优化
自己画的一个图

图中对run数组还没有理解，没有细画，在归并排序中会调用到快排的过长也没有画出来，因为这里都用到run数组，表示没理解。

下图中不是进行归并，而是进行快排递归

DualPivotQuicksort代码整理
由于p1 p2 两个值取得的左右端点的值，同时没有做相等判断，所有程序对没有相等数据可以实现排序

package alg.sort;public class DualQuickSort {    public void dualQuickSort(int[] A,int left,int right){        if(left>=right)        {//          System.out.println(left+"\t"+right);            return;        }        if(A[left]>A[right])        {            swap(A,left,right);        }        int less = left;        int great = right;        int pivot1 = A[left];        int pivot2 = A[right];        while (A[++less] < pivot1);        while (A[--great] > pivot2);        /*         * Partitioning:         *         *   left part           center part                   right part         * +--------------------------------------------------------------+         * |  < pivot1  |  pivot1 <= && <= pivot2  |    ?    |  > pivot2  |         * +--------------------------------------------------------------+         *               ^                          ^       ^         *               |                          |       |         *              less                        k     great         *         * Invariants:         *         *              all in (left, less)   < pivot1         *    pivot1 <= all in [less, k)     <= pivot2         *              all in (great, right) > pivot2         *         * Pointer k is the first index of ?-part.         */        outer:        for(int k = less - 1;++k<= great;){            int ak = A[k];            if(ak<pivot1){ // ak 小于 p1                swap(A,k,less); // 交换                less++;            }else if(ak>pivot2){ // ak > p2                  while (A[great] > pivot2) { // 找到不满足条件的位置                      if (great-- == k) {                         System.out.println("outer");                         break outer;                     }                 }                 if (A[great] < pivot1) { // a[great] <= pivot1，                       A[k] = A[less];  // less放到 k的位置,  k 位置的元素数保存在 ak中                       A[less] = A[great]; // great 放到less的位置                      ++less;  // 更新 less                  } else { // pivot1 <= a[great] <= pivot2                     A[k] = A[great];                 }                 /*                  * Here and below we use "a[i] = b; i--;" instead                  * of "a[i--] = b;" due to performance issue.                  */                 A[great] = ak; // ak 放到 great位置                  --great;            } // 其他情况就是中间位置，不用考虑         }        System.out.println("left :"+left+" less " + less + " great" + great+" right "+ right);        Print.printArray(A);            dualQuickSort(A,left,less-1);        dualQuickSort(A,less,great);        dualQuickSort(A,great+1,right);    }    public void swap(int[] A,int i,int j){        int t = A[i];        A[i] = A[j];        A[j] = t;    }    public static void main(String[] args){        int[] A = new int[]{13,3,65,97,76,10,35,71,5,7,3,27,49};        Print.printArray(A);        DualQuickSort dualQuickSort = new DualQuickSort();        int l = 0;        int r = A.length -1;        dualQuickSort.dualQuickSort(A,l,r);        Print.printArray(A);    }}