Java快速排序以及其优化（双路快排、三路快排）

1.快速排序

---

思想

快速排序是属于交换排序的基本思想。选择一个基准值val，把比val小的放在前面，比val大的放在后面，最后把val放在两个区域中间，val就到了最终的位置。

很明显快排是一个原地排序，也是一个不稳定排序。

空间复杂度：1.可以是为新数组开辟额外空间O（n） 2.当然也可以在原数组内交换得来O（1）

时间复杂度：O（nlogn）

代码实现

1.把数组第一个元素作为val，先用变量val存下来，设置两个指针，i用来标记遍历的元素，j-1用来标记<val区间的最后一个元素

2.i= start+1；j= start；遇到array[i]小于val的情况，就把array[i]和array[j]交换，小于区域扩张，j++；i++；遇到大于val的情况，就继续判断下一个i，i++；直到i>=j,把第一个元素和第j个元素交换，返回j的下标，为下一次递归边界做准备。

3.运用递归，接着把[start，key-1]和[key+1，end]进行第2步操作。

4.重复2.3.步，直到start>=end，退出递归。

start（j）--i----------------------end

start-----j---------i----------end

    public static int[] qiuckSort(int[] array){
        if(array.length <=1) return array;
        qiuck(array,0,array.length-1);
        return array;
    }
    private static void qiuck(int[] array ,int start, int end){
        if(start >=end) return;
        //选取key值
        int key = selectionKey(array, start, end);
        //key左边快排
        qiuck(array,start,key-1);
        //key右边快排
        qiuck(array,key+1,end);
    }
    //l…<……>…r
    //v……j……i
    private static int selectionKey(int[] array, int start, int end){
        //先设置为第一个元素
        int key = array[start];
        //[start,j]是<key的区域
        int j = start;
        //[j+1,i]是>key的区域
        int i = start+1;
        while(i <= end){
            //大于key不动 小于key跟array[j]交换
            if(array[i] <key){
                swap(array,j+1,i);
                j++;
            }
            i++;
        }
        //当遍历完之后把key放在j处 也就是最终位置处
       swap(array,start,j);
        return j;
    }

存在优化

1.当数组中元素基本上有序，每次取得第一个元素都是最大或最小值，会导致元素左右个数分布不不均匀，当完全有序时近似于一个O（n^2）的排序。

解决：随机选取val值，在与第一个元素交换，让递归顺利进行。

2.当数组中存在大量重复元素，无论是小于等于交换，还是小于交换，都会导致一边区域数据远大于另一半，当重复量很大时近似于一个O（n^2）的排序。

解决：运用双路快排，把等于val的大量元素均匀的分在两个区域里。

 

2.双路快排

---

思想

把等于val的元素均匀分布在小于、大于区域内。

代码实现

1.避免数组近乎有序，先随机取出一个val，和第一个元素交换。

2.定义两个指针，i从头开始指向小于val的区域后一个元素，j从尾开始指向大于val的第一个元素。

3.当i所指向的值小于等于val，i++，否则暂停。当j所指向的值大于等于val，j--，否则暂停。当i和j都暂停时，交换i和j所指位置的元素。直到i>j结束，让start赋给j所指向的位置，返回j。

4.重复2.3直到start>end，排序完成。

 

    public static int[] qiuckSort2(int[] array){
        if (array.length <=1) return array;
        qiuck2(array,0,array.length-1);
        return array;
    }
    private static void qiuck2(int[] array ,int start, int end){
        if(start >end) return;
        int key = selectionKey2(array,start,end);
        qiuck2(array,start,key-1);
        qiuck2(array,key+1,end);
    }
    private static int selectionKey2(int[] array, int start, int end){
        int random = (int)(Math.random()*(end-start+1)+start);
        swap(array,random,start);
        //找到一个随机key
        int value = array[start];
        //从头开始往后[start+1,i-1]
        int i = start+1;
        //从尾开始往前[j+1,end]
        int j = end;
        while (true){
                //相当于把等于key的值均分到两边
                while (i<=end && array [i] <value ) i++;
                while (j>=start+1 &&array [j] >value ) j--;
                //交换后两个指针都移动一步
            if(i>j) break;
            swap(array,i,j);
            i++;j--;
            }
        swap(array,start,j);
            return j;
        }

存在优化

1.当数组重复元素过多时，每次比较==val的元素会浪费时间，虽浪费的时间不足一提，但是还是可以优化的。

解决：三路快排，把等于value的元素放在另一个区间内，不参与下次的排序。

 

3.三路快排

---

思想

在二路排序的基础上，把等于value的元素放在另一个区间内，不参与下次的排序。

代码实现

1.避免数组近乎有序，先随机取出一个val，和第一个元素交换。

2.定义三个指针，lt从头开始指向小于val的区域后一个元素lt = start-1，i指向目前比较的元素i= start，gt从尾开始指向大于val的第一个元素gt = end+1。保证一开始都是空集合。

3.当i所指向的值小于等于val，swap（i，lt+1），lt++。当i所指向的值大于等于val，swap（i，gt-1）gt--，否则i++。直到i>=gt排序完成。将start和lt交换。

4.[start,lt-1]和[gt,end]重复2.3直到start>end，排序完成。

 

start----lt----i----gt-----end

小于 [start，lt-1]

等于[lt，gt-1]

大于[gt，end]

    public static void qiuckSort3(int[] array){
        if(array.length <=1)return;
        int start = 0;int end = array.length-1;
        qiuck3(array,start,end);
    }
    private static void qiuck3(int[] array ,int start, int end){
        if(start >end) return;
        if(end - start <=15){
            //如果数据量少就使用直接插入
            insert(array,start,end);
            return;
        }

        int random = (int)(Math.random()*(end-start+1)+start);
        swap(array,random,start);
        //找到一个随机key
        int value = array[start];
        int lt = start; int gt = end+1; int i = start+1;
        for(;i<gt;i++){
            if(array[i]<value){
                //放到小于的区域
                swap(array,lt+1,i);
                lt++;i++;
            }else if(array[i]>value){
                //放到大于区域
                swap(array,gt-1,i);
                gt--;
            }
        }
        swap(array,lt,start);
        //直接跳过相等元素的比较
        qiuck3(array,start,lt-1);
        qiuck3(array,gt,end);
    }

注：在此省略了直接插入和swap交换函数。

---

这样一步一步优化下来，快排适用了任何数据模式，具有了稳定的时间复杂度。