Java实现:交换排序之快速排序(Quicksort)、(基础、二路、三路快速排序)

1、简单快排
  • 所谓快速排序,利用的是一种“分而治之”的思想,有点像归并排序,但是还是有点区别的;
  • 快排思想是这样的:待排序数组中下标从l(左边)到r(右边)之间的一组数据,我们选择其中任意一个元素作为分区点pivot,然后这组数据中大于分区点元素的全部放到它的右边,小于它的全部放到左边,此时这组数据中,这个pivot元素以及排到了它将要排序后的位置;然后它左右两边的两组数据接着以这种方式选分区点、分割;知道最后每组数据中仅剩下一个元素,此时最开始要排序的数组已经排好序;
  • 这就是“分而治之”的思想,也是递归的思想;
    在这里插入图片描述1、先来实现递归的代码部分,解释一下代码,就是这个方法实现的功能:接收到一组数据,两个参数,左边界L和右边界R,我们得知道需要排序的区域,当然这样也是可以实现无序数组的部分内容排序:
private static void quickSortInternal(int[] array,int l,int r){
        if (l >= r){
            return;
        }
        //q就是当前的分区点pivot,partion()方法就是找到分区点并且返回这点的下标,下标为q
        int q = partition(array,l,r);
        //下面进行递归分区,下标左右两边的数组继续寻找pivot分区点,继续划分;
        //递归就是继续调用本方法,传入新的数组以及分区;
        quickSortInternal(array,l,q-1);
        quickSortInternal(array,q+1,r);

    }

2、下面是partioon()方法,分区函数,此方法作用就是随机选取一个元素作为分区点pivot,然后进行分区,就是将小的元素往前放,大的元素往后放;这里要注意一点,分区方法的操作,全部是在本数组中进行的,原地完成分区操作;
先来看看代码:

/**
     *  分区点
     * @param array 传入的数组
     * @param l  左边界
     * @param y  右边界
     */
    private static int partition(int[] array,int l,int r){
        //每次以第一个元素为分区点进行快排,
        //对一个近乎有序并且特别大的数列进行快排会发生栈溢出
        //因为栈内存不够用,递归不下去了;
        int randomIndex = (int) ((Math.random()*(r-l+1))+l);//获得一个随机的下标,随机数不超过数组的长度-1
        swap(array,l,randomIndex);//交换第一个元素跟随机的这个元素,这个swap方法自己写的
        int v = array[l];
        int j = l;
        int i = l + 1 ;
        for (;i <= r;i++){
            if (array[i] < v){
                swap(array,j+1,i);
                j++;
            }
        }
        swap(array,l,j);
        return j;
    }

画个图来解释一下代码,代码中的三个指针下标:L,i,j,(R不必解释,就是一个临界点)
如图所示:
在这里插入图片描述

  • 代码中有一个要注意的点,就是j一直指向小于分区点元素区域的最后一个元素,而且在分区的过程中,分区点元素一直在数组第一位,直到for循环最终进行完,就是j最终增加完了之后,从j元素的下一个元素开始全都是大于分区点元素的数据;此时交换j跟L所指向的pivot元素,此时分区点元素已经找到,并且已经分区完成,然后返回分区点元素的下标j;
  • 代码中还有一个优化点,一开始partion 分区选择pivot元素的话都是当前元素的第一个元素,可是当待排序元素近乎有序时,若选取的基准值恰好为最大值,此时分层退化成O(n),此时快排的时间复杂度退化为O(n^2);所以我们做一个小的优化,每次从待排序的
    数组中随机选取一个元素作为pivot基准值,这样可以保持均衡性;解决这个问题;
2、二路快排
首先简单说一下二路快速排序法的由来

如果数字集合中的数字重复度非常高,包含大量重复的元素,那么也会出现这种情况,也会导致数组长度不均衡,相同的元素都会放到分区点右边,分层下来后右边的元素会越来越多,此时分层下来的结果近乎n层,快排退化为O(n^2);

为了解决这种情况,我们想出了下面这种方法:

就是把相等的两个元素均衡的分配到基准值两边;这样的话分层下来后左右两个数组中相等的元素均衡分布;

那么如何做呢:

跟前面的简单快排不同,这次我们增加了一个遍历数组的指针,两个指针,就是两个下标,一个是 i 从前往后遍历,另一个是 j 从后往前遍历,当i遇到 >pivot 的时候停下,等 j ,然后j遇到 < pivot 的时候停下并且与停下来的 i 所指向的元素交换;然后再次开始遍历;结束条件 j < i;

下面先看一下我自己画的演示图:

在这里插入图片描述

Java代码实现partion()分区方法:
private static int partition2(int[] data,int left,int right){
//左下标跟右下标刚开始都分别指向小于pivot区域
//的前一个位置和大于pivot区域的后一个位置;
//当遍历开始后,交换开始后,i一直指向小于pivot区域的最后一个元素,
//j一直指向大于pivot的第一个元素;
        int i = left+1;
        int j = right;
        int value = data[left];
        while(i <= j){
            while(data[i] < value){
                i++;
            }
            while(data[j] > value){
                j--;
            }
            if (i > j){
                break;
            }
            swap(data,i,j);
            i++;
            j--;
        }
        swap(data,left,j);
        return j;
    }
  • 这里解释一下最后为何交换的是 j 为下标的元素,因为最外层 while 循环停止的时候,就是当 j 小于 i 的时候,不论什么情况都是j指向小于基准值元素的最后一个元素,所以直接交换基准值跟该元素,恰好把基准值放到了指定位置;
3、三路快排
  • 相比二路快排,当出现大量等于分区点值的时候,增加一个区域,等于区域,也就是说一共三个区域,“>”、"="、"<"三个区域;三路快排再一次减少了耗时;因为少了很多交换次数;
  • 三路快排的思想跟双路优点区别,当递归处理的时候,遇到等于v的元素直接不用管
    只需要处理小于v,大于v的元素就好了;
  • 自己总结了一下,因为是原地排序,所以很好理解,一共三个指针,lt,i,gt,,,,lt永远指向小于pivot区域的最后个元素,,,gt永远指向大于pivot区域的的第一个元素,,,i一直向后遍历元素;刚开始lt指向小于v区域的前一个位置,即初始位置,每当i遍历到一个小于v的元素的时候,交换lt+1元素跟i的元素,然后i指向下一个元素;同样gt,初始指向大于v区域的前一个位置;每当i遍历到一个大于v的元素的时候交换gt-1跟i的元素,但是此时注意,因为交换到i位置的元素不知道跟v谁大小,所以此处不能i++;同样的道理,当i遍历结束后,lt这个从后往前遍历的指针一定是指向小于v区域的最后一个元素,此时交换基准值元素跟lt处的元素,然后返回gt,即指定位置的元素的下标;
自己画的示意图

在这里插入图片描述

实现代码:
/**
     *  分区点
     * @param array 传入的数组
     * @param l  左边界
     * @param y  右边界
     */
    private static int partition3(int[] array,int l,int r){
        //三个指针,lt永远指向小于pivot区域的最后个元素
        //gt永远指向大于pivot区域的的第一个元素
        //i一直向后遍历元素;跟双路快排优点差别,双路快排是两个指针同时
        //分别从前向后、从后向前遍历;三路快排是三个指针,两个固定指向,一个从前向后遍历;
        int value = array[l];
        int lt = l;//刚开始lt指向小于v区域的前一个位置;即初始位置;
        int i = l+1;
        int gt = r+1;//同样gt后向前遍历,初始指向大于v区域的前一个位置;
        //下面开始遍历,从l+1处开始遍历
        while (i < gt){
            if (array[i] < value){
                swap(array,i,lt+1);
                lt++;
                i++;
            }else if(array[i] > value){
                swap(array,i,gt-1);
                gt--;
                //此处不能i++;因为当前i的元素是换回来的gt-1位置的元素
                //必须再次比较
                //前一个if入口的i++是因为当前i所指的元素就是换过来的小于
                //v的值,所以直接遍历下一个元素就行;
                // i++;
            }else{
                i++;
            }
        }
        //注意:这里的循环完成后,一定是gt指向小于v的最后一个区域;
        //所以这里可以直接交换l和gt的元素,然后返回gt 这个下标;
        swap(array,l,lt);
        return lt;
    }
4、快排总结
  • 20世纪最重要的算法之一,也是基于分治思想;
  • 时间复杂度:最好情况:O(n log n );
    最坏情况:O(n^2);要排序的数列已经完全有序了;
  • 稳定性:不稳定算法(若基准值为最后一个元素,5,4,3,2,6,1,5);
  • 3
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值