Java经典算法之快速排序详解

Java经典算法之快速排序详解

Java经典算法之快速排序详解

更新时间：2024年07月06日 09:04:52   作者：zcx-yyds

这篇文章主要给大家介绍了关于Java经典算法之快速排序的相关资料,需快速排序是一种分治法的排序算法,其基本思想是通过一趟排序将待排序的数据分割成独立的两部分,其中一部分的所有元素均比另一部分的元素小,然后分别对这两部分继续进行排序,需要的朋友可以参考下

一、什么是快速排序

快速排序是由冒泡排序演变而来，比冒泡排序更快的排序算法。之所以快，是因为快速排序用了分治法。

相同的是，与冒泡排序一样，快速排序也属于交换排序，通过元素之间的比较和交换来排序。

不同的是快速排序算法java，冒泡排序每一轮只把一个元素冒泡到数列的一端，而快速排序每轮挑选一个基准元素，让比它小的元素移动到一端，让比它大的元素移动到另一端，从而把数列拆解成两个部分。

这种每次将数列分为两个部分的方法就叫做分治法。

分治法的好处体现在相比于冒泡排序它会有更小的时间复杂度，对于n的元素的冒泡排序时间复杂度为O(n2),而快速排序总体的平均时间复杂度为O(nlogn)。

二、基准元素的选择

在使用分治法的过程中以基准元素为中心把其他元素移到它的两边，那么如何选择基准元素呢？

1、选择第一个元素

最简单的方法是直接选择数列第一个元素为基准元素，但是这种方法在有些特殊情况下会出现问题：

对于这种原本是逆序的数列，每轮都只能确定基准元素的位置，这种情况下快速排序需要进行n轮，时间复杂度退化到了O(n2)。

2、随机选择

为了解决时间复杂度过大的情况，我们可以随机选择一个元素，并与首位元素互换位置，虽然这种情况下也有几率选到数列的最大或最小值，但大多情况下都是可以的。

所以Java经典算法之快速排序详解，虽然快速排序的平均时间复杂度为O(nlogn)，但最坏情况下也可以达到O(n2)。

三、元素的交换

选好了基准元素，就要将其他元素移到基准元素两边，具体实现有两种方法：

1、双边循环法

对以下数列按从小到大进行排序：

首先，选定基准元素p，并设置左右两个指针 l 和 r

开始循环后，从r指针开始，让r指针元素与基准元素做比较，如果大于等于p，则r指针向左移动；如果小于p，则停止移动，换到l指针。

对于当前数列，r指针元素为1，1

换到l指针后快速排序算法java，让l指针元素与基准元素做比较，如果小于等于p，则l指针向右移动；如果大于p，则停止移动。

按照此思路，后续步骤如下：

实现代码如下：

import java.util.Arrays;
public class quickSort {
    public static void quickSort(int arr[],int startIndex,int endIndex){
        //递归结束条件为startIndex大于或等于endIndex
        if(startIndex>=endIndex){
            return;
        }
        //得到基准元素位置
        int pIndex=partition(arr,startIndex,endIndex);
        //根据基准元素分两部分进行递归排序
        quickSort(arr,startIndex,pIndex-1);
        quickSort(arr,pIndex+1,endIndex);
    }
    /*
    * 分治法（双边循环法）
    * arr  待排序数组
    * startIndex  起始下标
    * endIndex  结束下标
    * */
    public static int partition(int arr[],int startIndex,int endIndex)
    {
        int p=arr[startIndex];//基准元素(可取随机位置)
        int l=startIndex;//左指针
        int r=endIndex;//右指针
        while(l!=r){
            //控制右指针向左移动，找到小于基准元素的那个数
            while((lp)){
                r--;
            }
            //控制左指针向右移动，找到大于基准元素的那个数
            while((l<r)&&(arr[l]<=p)){
                l++;
            }
            //交换l指针和r指针所指的元素
            if(l<r){
                int tmp=arr[l];
                arr[l]=arr[r];
                arr[r]=tmp;
            }
        }
        //交换基准元素和重合点的元素
        arr[startIndex]=arr[l];
        arr[l]=p;
        return l;
    }
    public static void main(String[] args) {
        int arr[]={4,7,6,5,3,2,8,1};
        quickSort(arr,0,7);
        System.out.println(Arrays.toString(arr));
    }
}

2、单边循环法

双边循环更加直观，但代码比较麻烦，而单边循环法从数列的一边对元素进行遍历交换。

开始循环选定基准元素p，再设置一个mark指针指向数列起始位置，mark代表着小于基准元素区域的右边界。

从基准元素的下一位开始遍历，若元素大于基准元素，则继续往后遍历。如果小于基准元素，先将mark指针右移一位，然后将最新遍历的元素与基准元素交换。

单边循环法与双边循环法主要是函数的实现不一样

/*
     * 分治法（单边循环法）
     * arr  待排序数组
     * startIndex  起始下标
     * endIndex  结束下标
     * */
    public static int partition(int arr[],int startIndex,int endIndex)
    {
        int p=arr[startIndex];//基准元素(可取随机位置)
        int mark=startIndex;
        for(int i=startIndex+1;i<=endIndex;i++){
            if(arr[i]<arr[mark]){
                mark++;
                int tmp=arr[mark];
                arr[mark]=arr[i];
                arr[i]=tmp;
            }
        }
        //交换基准元素和mark指针的元素
        arr[startIndex]=arr[mark];
        arr[mark]=p;
        return mark;
    }

可以看出，单边循环法只需要一个循环即可，比双边循环法要简单很多。

附：算法优化

快速排序在最坏情况下，时间复杂度竟然达到了O(n2)，这哪里快速啊，所以下面就要进行优化了。

优化基准的选取

共有两种方案： 1️⃣随机选取基准法，这要是倒霉起来，依然有可能会次次都随机选到最极端最坏的情况，所以这个不用。 2️⃣三数取中法快速排序算法java，这个可以保证不会让你选到最极端最坏的情况。

三数取中法：在上面的算法中，我们的基准选取的都是left下标，

而三数取中指的是在left，right，mid( (left + right)/2 )这三个下标在中选取一个中间值作为基准，不是最大也不是最小，就保证了不会出现极端情况。

出现了以上的最坏情况，也就是让快速排序变成了二分查找。

    private static int minThree(int[]array,int left,int right) {
        //三数取中法，优化递归实现的快速排序
        //使得最坏情况时，快速排序变为二分查找
        int mid = (left+right)/2;
        if(array[right] > array[left]) {
            int tmp = array[left];
            array[left] = array[right];
            array[right] = tmp;
        }
        if(array[mid] > array[left]) {
            return left;
        }
        if(array[mid] > array[right]) {
            return mid;
        }
        return right;
    }

优化少量数据时的排序方案

数据量大时就像二叉树一样，每一组数据往下走一层都会被分成两组，而到了最后几层，则会因为数据量的庞大而被分成许多组进行递归，此时的递归开销就会很大Java经典算法之快速排序详解，很有可能导致~~栈溢出~~，

因此我们可以设定一个数量闸口，当每组的数据小的到了这个闸口，就采用比较简单的直接插入排序。

而且在快速排序的不断递归下，数据一定是越来越有序的，直接插入排序的效率也会更高。

数据小时

此时即便是一开始就用直接插入排序，时间也会相差无几。

优化后的完整代码

public class QuickSort {
    /**
     * 快速排序
     * 时间复杂度：代码未优化时：最好情况（满二叉树或完全二叉树）：O(n*logn)，    最坏情况(顺序和逆序时)：O（n^2）
     * 空间复杂度：代码未优化时：最好情况（满二叉树或完全二叉树）：O（logn），    最坏情况(顺序和逆序时)：O（n）
     * 稳定性：不稳定
     * @param array
     */
    public static void quickSort(int[] array) {
        quick(array,0, array.length-1);
    }
    private static void quick(int[] array,int left,int right) {
        if(left >= right) {
            return;
        }
        // 设置数量闸口，
        // 数量小，使用直接插入排序
        if(right - left + 1 < 14) {
            InsertSort(array);
            return;
        }
        
        // 将三数取中法取得的中间值换到left处
        swap(array,minThree(array,left,right),left);
        int piovt = partition(array,left,right);
        quick(array, left, piovt-1);
        quick(array,piovt+1,right);
    }
    //挖坑法
    private static int partition(int[] array,int left,int right) {
        // 在left下标挖一个坑
        int tmp = array[left];
        while (left < right) {
            // 让right下标去找比tmp小的数
            while (right > left && array[right] >= tmp) {
                right--;
            }
            // 填left下标的坑，此时right下标变成一个坑了
            array[left] = array[right];
            // 让left下标去找比tmp大的数
            while (left < right && array[left] <= tmp) {
                left++;
            }
            // 填right下标的坑，此时left下标变成一个坑了
            array[right] = array[left];
        }
        // 将基准值放到合适的位置
        array[left] = tmp;
        // 返回基准下标
        return left;
    }
    //Hoare法
    private static int partition3(int[] array,int left,int right) {
        // 基准值
        int tmp = array[left];
        // 基准下标
        int index = left;
        while (left < right) {
            // 让right找比tmp小的数
            while (right > left && array[right] >= tmp) {
                right--;
            }
            // 让left找比tmp大的数
            while (left < right && array[left] <= tmp) {
                left++;
            }
            // 让left与right这两个数进行交换
            swap(array,left,right);
        }
        // 将基准值放到合适的位置
        swap(array,index,right);
        // 返回基准下标
        return right;
    }
    //前后指针法
    private static int partition2(int[] array, int left, int right) {
        int prev = left ;
        int cur = left+1;
        while (cur <= right) {
            if(array[cur] < array[left] && array[++prev] != array[cur]) {
                swap(array,cur,prev);
            }
            cur++;
        }
        swap(array,prev,left);
        return prev;
    }
    private static int minThree(int[]array,int left,int right) {
        //三数取中法，优化递归实现的快速排序
        //使得最坏情况时，快速排序变为二分查找
        int mid = (left+right)/2;
        if(array[right] > array[left]) {
            int tmp = array[left];
            array[left] = array[right];
            array[right] = tmp;
        }
        if(array[mid] > array[left]) {
            return left;
        }
        if(array[mid] > array[right]) {
            return mid;
        }
        return right;
    }
    private static void swap(int[] array,int a,int b) {
        int tmp = array[a];
        array[a] = array[b];
        array[b] = tmp;
    }
}

总结

到此这篇关于Java经典算法之快速排序详解的文章就介绍到这了,更多相关Java快速排序内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！