507、java-快速排序

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个元素要O(nlogn)次比较。在最坏状况下则需要O(n^2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他O(nlogn)算法更快，因为它的内部循环可以在大部分的架构上很有效率地被实现出来

实现思路：
快速排序使用分治策略(Divide and Conquer)来把一个序列分为两个子序列。步骤为：
1.从序列中挑出一个元素，作为"基准"(pivot).
2.把所有比基准值小的元素放在基准前面，所有比基准值大的元素放在基准的后面（相同的数可以到任一边），这个称为分区(partition)操作。
3.对每个分区递归地进行步骤1~2，递归的结束条件是序列的大小是0或1，这时整体已经被排好序了。

如上图：每次选择的基准都是区间最左边的元素。
主要注意 基准：key
左右区间范围：L与R，从右边先开始右边的元素大于基准则向前移动一步，直至找到小于基准的数或LR相遇，找到小于基准的数覆盖L位置所在元素（由于L从基准数开始，已被临时取出为key值），开始从左边L向后寻找，小于基准数则L++(L与R相遇结束)，大于基准数的元素覆盖之前R的位置，转而从R开始向前寻找，依次交替直至L与R相遇。

快速排序方式
快速排序根据基准数的选取不同又分为：
1.固定的切分方式：默认左(右)边元素为基准数由两边开始进行排序，如上图所示
2.三数取中：比较左、中、右三个元素值选择一个最大或最小的元素放置与最左边，然后开始固定切分方式；
3.随机快速排序：在区间数据中随机选择一个元素用于基准数

区别：三者主要在于基准元素的选取上。主要看将排序数据是什么样的，假如一组数据本身就是从大到小排序好的，现在用快速排序来完成从小到大，采用固定切分的话，每次数据都要进行覆盖操作。

代码：

固定切分

    //固定的切分方式
    public static int partition(int []array,int lo,int hi){
        int key=array[lo];
        while(lo<hi){
            while(array[hi]>=key&&hi>lo){//从后半部分向前扫描
                hi--;
            }
            array[lo]=array[hi];//覆盖元素
            while(array[lo]<=key&&hi>lo){//从前半部分向后扫描
                lo++;
            }
            //覆盖元素
            array[hi]=array[lo];
        }
        //覆盖元素
        array[hi]=key;
        return hi;
    }


   public static void quickSort(int[] arr,int left,int right){
        if(left >= right)
            return;
        int pivot = partition(arr, left, right);
        quickSort(arr,left,pivot-1);
        quickSort(arr,pivot+1,right);
    }

三数取中：

//三数取中
    public static int partition3(int []array,int lo,int hi){
       //获取中间数坐标
        int mid=lo+(hi-lo)/2;
        if(array[mid]>array[hi]){
            swap(array,mid,hi);
        }
        if(array[lo]>array[hi]){
            swap(array,lo,hi);
        }
        if(array[mid]>array[lo]){
            swap(array,mid,lo);
        }
        int key=array[lo];
//以上是三数比较选择一个合适的基准数key
        while(lo<hi){
            while(array[hi]>=key&&hi>lo){
                hi--;
            }
            array[lo]=array[hi];
            while(array[lo]<=key&&hi>lo){
                lo++;
            }
            array[hi]=array[lo];
        }
        array[hi]=key;
        return hi;
    }

   public static void quickSort(int[] arr,int left,int right){
        if(left >= right)
            return;
        int pivot = partition(arr, left, right);
        quickSort(arr,left,pivot-1);
        quickSort(arr,pivot+1,right);
    }

随机：

 //--随机快速排序-调用入口
    public static void randomQuickSort(int [] arr) {
        //超过一个元素进行排序
        if(arr == null && arr.length <2) {
            return ;
        }
        //区间范围：按照角标方式，0--（length-1）
        randomQuickSort(arr,0,arr.length-1);
    }

    public static void randomQuickSort(int[] arr, int L, int R) {
        if(L<R) {
            //选择中间坐标，左边比它小，右边比它大继续拆分区间
            int  part = partition4(arr,L,R);
            randomQuickSort(arr,L,part-1);
            randomQuickSort(arr,part+1,R);
        }
    }

    private static int partition4(int[] arr, int L, int R) {
        int less = L - 1; //小于key的区间坐标 0-less
        //只加了这么一句代码。指在L ~ R范围内产生一个随机数
        int ranR = L + (int)(Math.random() * (R-L+1));
        //把随机数作为索引,将索引对应值与最后一位值 R 交换，此时最后一位值充当key的作用，也可以说此时 key=arr[R]
        swap(arr,ranR,R);
        int more = R; //大于key的区间坐标 more-R
        while(L < more) {
            if(arr[L] < arr[R]) {
                //小于key，区间扩大一步，确保0-less区间元素必定小于key
                // less前面的必定小于key，L前面的不一定小于key，有可能相等，
                swap(arr,++less,L++);
            }else if(arr[L] > arr[R]) {
                swap(arr,--more,L);//大于key交换至元后半部分，从末尾坐标向前递减交换，因为此时末尾元素充当key
            }else {
                L++;//相等则寻找下一个元素
            }
        }
        //将key与最靠前的一个大于它的元素交换位置，并返回此时key的坐标，用于区间拆分
        swap(arr,R,more);
        return more;
    }

随机快排主要在于这个随机基准数的选择上：
1.在排序范围内随机选择一个基准数与数组最后一个元素交换位置，此时末尾元素就是基准数key
2.三个坐标指针用于数据排序，less用于确定小于基准数的数据范围，L元素递增比较指针用于记录比较数保证与more一起确保所有元素都与key做过比较，more记录比key大的值，范围是more-length（因为最后末尾元素key会交换至前面），与基准数key交换元素的坐标前面保证小于key，后面大于key范围key的坐标
3.主要理解less，L，more，R的关系，最后由于key在末尾需要交换位置。
0-less<key；
0-L<=key；
more+1>key;(最后交换元素后more就是key)

来源：http://www.cnblogs.com/eniac12/p/5329396.html#s32
https://www.cnblogs.com/coderising/p/5708801.html