JAVA数据结构--快速排序

快排概念

快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），一种排序算法，最早由东尼·霍尔提出。在平均状况下，排序个项目要（大O符号）次比较。在最坏状况下则需要次比较，但这种状况并不常见。事实上，快速排序通常明显比其他算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

实现思想

快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。

步骤为：

1. 从数列中挑出一个元素，称为"基准"（pivot），
2. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3. 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

借用下啊哈算法的图：

i和j分别为左哨兵和右哨兵，这里枢纽元定为6，然后分别从左往右（i++）和右往左（j--）开始遍历

左哨兵查找比6大的元素，右哨兵查找比6小的元素

第一次交换结果

第二次交换结果

相遇后直接与枢纽元交换

然后再递归排序就行

---

快排核心算法代码

public static <T extends Comparable<? super T>> void quicksort(T[] a,int left,int right) {
        /*
         * 当数组不小于3时，才推荐使用快排
         * */
        if(left+CUTOFF<=right)
        {
            //取出枢纽元，枢纽元的位置为right-1
            T privot=median3(a, left, right);
            
            int i=left,j=right-1;
            for(;;)
            {
                while(a[++i].compareTo(privot)<0) {}//i哨兵向右遍历
                while(a[--j].compareTo(privot)>0) {}//j哨兵向左遍历
                if(i<j)
                    swapReferences(a, i, j);
                else
                    break;
            }
            /*
             * for循环终止条件为i和j相遇，此时再将枢纽元归位
             * */
            swapReferences(a, i, right-1);
            
            quicksort(a, left, i-1);//对左半部进行递归
            quicksort(a, i+1, right);//对右半部进行递归
        }
        else
        {}
    }

全部代码实现

public class MyQuickSort {
    private static final int CUTOFF=3;
    public static <T extends Comparable<? super T>> void quicksort(T[] a) {
        quicksort(a,0,a.length-1);
    }
    public static <T extends Comparable<? super T>> void quicksort(T[] a,int left,int right) {
        /*
         * 当数组不小于3时，才推荐使用快排
         * */
        if(left+CUTOFF<=right)
        {
            //取出枢纽元，枢纽元的位置为right-1
            T privot=median3(a, left, right);
            
            int i=left,j=right-1;
            for(;;)
            {
                while(a[++i].compareTo(privot)<0) {}//i哨兵向右遍历
                while(a[--j].compareTo(privot)>0) {}//j哨兵向左遍历
                if(i<j)
                    swapReferences(a, i, j);
                else
                    break;
            }
            /*
             * for循环终止条件为i和j相遇，此时再将枢纽元归位
             * */
            swapReferences(a, i, right-1);
            
            quicksort(a, left, i-1);//对左半部进行递归
            quicksort(a, i+1, right);//对右半部进行递归
        }
        else
        {}
    }
    /*
     * 数组中数值交换
     * */
    public static <T> void swapReferences(T[] a,int index1,int index2) {
        T tmp=a[index1];
        a[index1]=a[index2];
        a[index2]=tmp;
    }
    /*
     * 确定枢纽元，枢纽元的位置放在right-1位置
     * */
    private static <T extends Comparable<? super T>> T median3(T[] a,int left,int right) {
        int center=(left+right)/2;
        if(a[center].compareTo(a[left])<0)
            swapReferences(a, left, center);
        if(a[right].compareTo(a[center])<0)
            swapReferences(a, center, right);
        if(a[right].compareTo(a[left])<0)
            swapReferences(a, left, right);
        
        swapReferences(a, center, right-1);
        return a[right-1];
    }
}