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// 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);
    }

}