zoukankan      html  css  js  c++  java
  • 数据结构 快速排序

      快速排序是对冒泡排序的一种改进,是所有内部排序算法中平均性能最优的排序算法。其基本思想是基于分治法的:在待排序数组L[1...n]中任取一个元素pivot作为基准,从数组的两端开始扫描。设两个指示标志(low指向起始位置,high指向末尾),先从后向前扫描(high递减),如果high位置的元素小于pivot,就交换low和high位置的元素,然后从前向后扫描(low递增),如果low位置的元素大于pivot,就交换low和high位置的元素。重复上述过程,直到low>=high,然后把基准放到low位置上,一趟排序就完成了,将一个元素(基准)放到了最终位置上,不产生有序子序列。将待排序数组划分为两部分即L[1...k-1]和L[k+1...n],使得前半部分L[1...k-1]所有元素小于pivot,后半部分L[k+1...n]所有元素大于或等于pivot。接着采用递归的方式分别对前半部分和后半部分排序,直到每部分只有一个元素或空为止,即所有元素放在了最终位置上。

      之所以快速排序比较快,是因为相比于冒泡排序,每次交换是跳跃式的。每次排序时选取一个基准,将小于基准的数全部放到基准点的左边,将大于或等于基准的数全部放到基准的右边,在每次交换时不会像冒泡排序一样只能在相邻的数之间进行交换,增大了交换距离,减少了总的比较和交换次数,加快了速度。在最坏情况下,仍可能交换相邻的两个数。

      假设对“6 1 2 7 9 3 4 5 10 8”这10个数进行排序:

      从后向前扫描

      

      交换7和5

      

      交换之后:6 1 2 5 9 3 4 7 10 8

      交换9和4

      

      交换之后:6 1 2 5 4 3 9 7 10 8

      i>=j,交换6和3

      

      交换之后:3 1 2 5 4 6 9 7 10 8

      一趟排序结束。

     1 public class QuickSort {
     2 
     3     public static void quickSort(int[] arr, int low, int high) {
     4         // 至少有两个元素需要排序
     5         if (low < high) {
     6             int curLow = low;
     7             int curHigh = high;
     8             int temp = arr[low];
     9 
    10             while(curLow < curHigh) {
    11                 // 从右向左扫描,寻找第一个比基准小的数
    12                 while(curLow < curHigh && arr[curHigh] >= temp) {
    13                     curHigh--;
    14                 }
    15                 arr[curLow] = arr[curHigh];
    16 
    17                 // 从左向右扫描,寻找第一个比基准大的数
    18                 while(curLow < curHigh && arr[curLow] <= temp) {
    19                     curLow++;
    20                 }
    21                 arr[curHigh] = arr[curLow];
    22             }
    23 
    24             // 基准归位
    25             arr[curLow] = temp;
    26 
    27             // 基准位置左边子序列递归排序
    28             quickSort(arr, low, curLow - 1);
    29             // 基准位置左边子序列递归排序
    30             quickSort(arr, curLow + 1, high);
    31         }
    32     }
    33 
    34     public static void main(String[] args) {
    35         int[] arr = {15, 1, 17, 3, 6, 8};
    36         QuickSort.quickSort(arr, 0, arr.length - 1);
    37 
    38         for (int i = 0, length = arr.length; i < length; i++) {
    39             System.out.printf(" %d", arr[i]);
    40         }
    41     }
    42 
    43 }

      结果如下:

     1 3 6 8 15 17

      上述代码每次以当前数组中第一个元素作为基准对数组进行划分。

      快速排序性能分析:

      空间复杂度:因为快速排序是递归的,所以需要借助一个递归工作栈来保存每一层递归调用的必要信息,容量应与递归调用的最大深度一致。最坏情况下n-1次递归调用,栈的深度为O(n);最好和平均情况下栈的深度为O(log2n)。所以,空间复杂度在最坏情况下为O(n),平均情况下为O(log2n)。

      时间复杂度:快速排序的性能主要取决于划分操作的好坏。最坏情况下待排序数组基本有序或基本逆序时,每一次递归划分的两个区域分别包含n-1个元素和0个元素,快速排序退化成冒泡排序,时间复杂度为O(n2)。最好情况下最平衡划分,两个子数组长度不超过n/2,时间复杂度为O(nlog2n)。而快速排序平均情况下运行时间接近于最好情况下的运行时间,即时间复杂度在最坏情况下为O(n2),平均情况下为O(nlog2n)。

      稳定性:如果右端区间有两个相同的关键字,且均小于基准,那么交换到左端区间后,它们的相对次序会变化,即快速排序不稳定。例如,表L={3, 2, 2},经过一趟排序后L={2, 2, 3},最终结果是L={2, 2, 3},2与2的相对次序发生了变化。

      改进方案

      1 使用直接插入排序

      当递归过程中划分得到的子数组长度较小时,可以使用直接插入排序完成排序工作。

    1 public static void quick(int []array ,int lo,int hi){
    2         if(hi-lo+1<10){
    3             insertSort(array);
    4         }else{
    5             quickSort(array,lo,hi);
    6         }
    7     }

      2 选取好的基准

      尽量选取可以把元素平衡划分的基准,有三种方法:固定切分,随机切分和三取样切分。固定切分的效率低。随机切分是常用的一种切分,效率高,最坏情况下时间复杂度有可能为O(n2)。三取样切分最理想,具体操作:选取数组的头尾和中间这3个元素,取这3个元素的中间值作为基准。

     1 public static int partition(int []array,int lo,int hi){
     2         //三数取中
     3         int mid=lo+(hi-lo)/2;
     4         if(array[mid]>array[hi]){
     5             swap(array[mid],array[hi]);
     6         }
     7         if(array[lo]>array[hi]){
     8             swap(array[lo],array[hi]);
     9         }
    10         if(array[mid]>array[lo]){
    11             swap(array[mid],array[lo]);
    12         }
    13         int key=array[lo];
    14         
    15         while(lo<hi){
    16             while(array[hi]>=key&&hi>lo){
    17                 hi--;
    18             }
    19             array[lo]=array[hi];
    20             while(array[lo]<=key&&hi>lo){
    21                 lo++;
    22             }
    23             array[hi]=array[lo];
    24         }
    25         array[hi]=key;
    26         return hi;
    27     }
    28     
    29     public static void swap(int a,int b){
    30         int temp=a;
    31         a=b;
    32         b=temp;
    33     }
    34     public static void sort(int[] array,int lo ,int hi){
    35         if(lo>=hi){
    36             return ;
    37         }
    38         int index=partition(array,lo,hi);
    39         sort(array,lo,index-1);
    40         sort(array,index+1,hi);
    41     }

      

      参考资料

      《2017年数据结构联考复习指导》 P287-288

      快速排序(java实现)

      坐在马桶上看算法:快速排序

  • 相关阅读:
    IO 模型知多少 | 代码篇
    IO 模型知多少 | 理论篇
    ASP.NET Core 反向代理部署知多少
    ASP.NET Core 借助 Helm 部署应用至K8S
    Orleans 知多少 | 4. 有状态的Grain
    Goodbye 2019,Welcome 2020 | 沉淀 2020
    Orleans 知多少 | 3. Hello Orleans
    集群环境下,你不得不注意的ASP.NET Core Data Protection 机制
    .NET Core 使用 K8S ConfigMap的正确姿势
    ASP.NET Core知多少(13):路由重写及重定向
  • 原文地址:https://www.cnblogs.com/WJQ2017/p/8340156.html
Copyright © 2011-2022 走看看