加入收藏 | 设为首页 | 会员中心 | 我要投稿 常州站长网 (https://www.0519zz.com/)- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置: 首页 > 教程 > 正文

排序算法概括之快速排序

发布时间:2021-11-18 18:38:41 所属栏目:教程 来源:互联网
导读:一,快速排序介绍 快速排序与归并排序一样,也是基于分治的递归算法,体现在:在每一趟快速排序中,需要选出枢轴元素,然后将比枢轴元素大的数组元素放在枢轴元素的右边,比枢轴元素小的数组元素都放在枢轴元素的左边。然后,再对分别对 枢轴元素左边 和 枢轴
一,快速排序介绍
 
快速排序与归并排序一样,也是基于分治的递归算法,体现在:在每一趟快速排序中,需要选出枢轴元素,然后将比枢轴元素大的数组元素放在枢轴元素的右边,比枢轴元素小的数组元素都放在枢轴元素的左边。然后,再对分别对 枢轴元素左边 和 枢轴元素右边的元素进行快速排序。
 
二,快速排序算法分析
 
 ①相比于直接插入排序,快排合适于数据量大(上百万)的情形,而插入排序适合于小数据量的情形。因为,在数据量小的情形下,快排的递归是需要一定的开销的。
 
②相比于归并排序,归并排序的比较次数要比快速排序少,但是它需要一个额外的临时数组,而且移动的元素多。而快速排序不需要显示地声明一个临时数组,它用的是递归栈。在C++四使用它来作为标准的排序程序,而Java中则是用归并排序来作为标准的排序。
 
③快速排序主要有两个基本操作:一是选取枢轴元素,另一个则是递归分割数组。枢轴元素的选取对快速排序的效率至关重要,因为它决定了递归的深度。如果枢轴元素刚好处于数组的中间值,那么,数组在分割时就分成了平均的两部分。这样的递归的效率就好。如果每次选取的枢轴元素都是最大/最小 的那个元素,则快排复杂度达到了O(N^2),而且还用了递归栈空间。
 
④枢轴元素的选取可以采用三数取中法。所谓三数取中法,即给定一个数组,选取数组中的第一个元素,最后一个元素,和中间那个元素。哪个元素的值位于中间,则它作为枢轴元素。比如,a[0]=5 , a[4]=1, a[9]=10,  那么  a[4]<a[0]<a[9]  ,故a[0]是枢轴元素。
 
采用三数取中法时,会有一个问题,就是当数组不断的递归划分变小之后,枢轴左边的元素个数不足3,这样三数取中法就失去了应有的意义。此外,正如前面提到,对于小数组而言,插入排序反而比快速排序的效率更高。
 
正是基于以上两个原因,我们可以将快速排序与插入排序结合。当递归划分的数组变小之后,达到某个值(CUTOFF)时,采用插入排序。(代码83行)
 
三,快速排序算法实现
 
public class QuickSort {
 
    private static final int CUTOFF = 10;
   
   
    /**
    *
    * @param arr
    *            待排序的数组
    */
    public static <T extends Comparable<? super T>> void quickSort(T[] arr) {
        quickSort(arr, 0, arr.length - 1);
    }
 
    /**
    * 快排的基本操作:通过三数取中法来选取枢轴元素
    *
    * @param arr
    *            在[left, right]之间选择pivot element
    * @param left
    *            index of arr to chose pivot element
    * @param right
    *            index of arr to chose pivot element
    * @return pivot element
    */
    private static <T extends Comparable<? super T>> T media3(T[] arr,
            int left, int right) {
 
        int center = (left + right) / 2;
        if (arr[center].compareTo(arr[left]) < 0)
            swapReference(arr, center, left);
        if (arr[right].compareTo(arr[left]) < 0)
            swapReference(arr, right, left);
 
        // 参考前面两个if比较之后,最小的元素被放置在
        // arr[left],然后下面再比较中间与最右的元素,将最大的元素放在arr[right],而arr[center]存放中间元素(pivot)
        if (arr[right].compareTo(arr[center]) < 0)
            swapReference(arr, right, center);
       
        swapReference(arr, center, right - 1);//将枢轴元素放在 arr[right-1]上.便于快排交换元素
        return arr[right - 1];
    }
 
    private static <T extends Comparable<? super T>> void swapReference(
            T[] arr, int from, int to) {
        T tmp = arr[from];
        arr[from] = arr[to];
        arr[to] = tmp;
    }
 
    /**
    * 实现了递归的快排主例程, internal quicksort method that makes recrusive calls
    *
    * @param arr
    *            an array of comparable items
    * @param left
    *            the left-most index of subarray
    * @param right
    *            the right-most index of subarray
    */
    private static <T extends Comparable<? super T>> void quickSort(T[] arr,
            int left, int right) {
        if(left + CUTOFF <= right)
        {
            T pivot = media3(arr, left, right);
           
            //begin partitoning
            int i = left, j = right - 1;//在media3中已经将比pivot小的元素放到了a[left]上,把pivot放到了arr[right-1]上,故下面的while中是 ++i 和 --j
            for(;;)
            {
                while(arr[++i].compareTo(pivot) < 0){}
                while(arr[--j].compareTo(pivot) > 0){}
                if(i < j)
                    swapReference(arr, i, j);
                else
                    break;
            }
            swapReference(arr, i, right - 1);//restore pivot
            quickSort(arr, left, i - 1);
            quickSort(arr, i + 1, right);
        }else
            //Do an insertion sort on the subarray
            insertSort(arr, left, right);
    }
}
 
①第3行CUTOFF定义当数组中元素个数为10以下时,采用插入排序。
 
②第11行的quickSort方法是快排对外提供的接口
 
③第26行的media3方法实现了三数取中选取枢轴元素。其实,它不仅仅返回了枢轴元素,它还改变了原数组:
 
1) 它将三个数中最大的那个数放在了数组末尾arr[right]---(比枢轴小的放在枢轴元素左边)
 
2) 它将三个数中最小的那个数放在了数组的开头arr[left]---(比枢轴大的放在枢轴元素右边)
 
3) 它将三个数中的中间那个数(枢轴元素)放在了 arr[right-1]位置处!!!---(在第71-72行选取是否交换元素时可以不受枢轴影响)
 
这是快排算法实现的技巧。
 
④第61行的quickSort方法则是实现快速递归分割的主例程。首先在第65行选取枢轴元素,第71行,在数组左边寻找比枢轴元素大的元素;第72行,在数组右边寻找比枢轴元素小的元素,第73-74行将之进行交换。可以看出,这些语句实现得非常精巧:在循环中只有自增和自减操作,以及判断语句,因此执行速度是很快的。
 
在media3中已经将比pivot小的元素放到了a[left]上,把pivot放到了arr[right-1]上,故下面的while中是 ++i 和 --j
⑤第73行if语句 当 i > j 时 表示一趟快排已经结束,第78行将枢轴元素放到它的最终位置。对于快排而言,每进行一趟,枢轴元素的位置就被唯一确定下来,以后都不再变。
 
⑥第79 和 80行,对枢轴元素左右两个的子数组递归调用。这样,将原问题,划分成了两个子问题。
 
可以写出它们的递归表达式:T(N)=T(i)+T(N-i-1)+O(N)
 
⑦当 快速排序划分的子数组足够小时(CUTOFF),不再采用快速排序,而是用插入排序。这样,进一步优化了快速排序的速度。
 
用到的插入排序实现如下:
 
private static <T extends Comparable<? super T>> void insertSort(T[] a, int left ,int right){
        for(int p = left + 1; p <= right; p++)
        {
            T tmp = a[p];//保存当前位置p的元素,其中[0,p-1]已经有序
            int j;
            for(j = p; j > 0 && tmp.compareTo(a[j-1]) < 0; j--)
            {
                    a[j] = a[j-1];//后移一位
            }
            a[j] = tmp;//插入到合适的位置
        }
 
四,快速排序算法复杂度分析
 
①快速排序的时间复杂度与枢轴元素的选取息息相关。平均情况下,时间复杂度为O(NlogN),最坏情况下为O(N^2)
 
②枢轴元素的选取有多种方式:比如上面提到的三数取中,也可以采用随机化算法来选取。采用三数取中时,几乎不会出现最坏的情况。相对基于内存排序的其他算法,快速的效率是很高的,它的时间复杂度的常数因子很小。大约是1.3,而归并大约是1.4 ----不太确定。  1.3NlogN
 
③快排用到了递归,当数组元素个数很少时,递归的开销就有点大了,故在程序中可将快排与插入排序结合起来。

(编辑:常州站长网)

【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!

    热点阅读