Java排序算法之快速排序

交换类排序主要是通过两两比较待排元素的关键字，若发现与排序要求相逆，则“交换”
之。快速排序是交换类排序的一种。本篇文章讲解以下内容：

• 基本思想
• 源码
• 源码解析
• 算法原理
• 效率分析

基本思想

快速排序是将分治法运用到排序问题中的一个典型例子，快速排序的基本思想是：通过
一个枢轴（pivot）元素将 n 个元素的序列分为左、右两个子序列 Ll 和 Lr，其中子序列 Ll中的元素均比枢轴元素小，而子序列 Lr 中的元素均比枢轴元素大，然后对左、右子序列分别进行快速排序，在将左、右子序列排好序后，则整个序列有序，而对左右子序列的排序过程直到子序列中只包含一个元素时结束，此时左、右子序列由于只包含一个元素则自然有序。用分治法的三个步骤来描述快速排序的过程如下：
划分步骤：通过枢轴元素 x 将序列一分为二， 且左子序列的元素均小于 x，右子
序列的元素均大于 x；
治理步骤：递归的对左、右子序列排序；
组合步骤：无
从上面快速排序算法的描述中我们看到，快速排序算法的实现依赖于按照枢轴元素 x对待排序序列进行划分的过程。对待排序序列进行划分的做法是：使用两个指针 low 和 high 分别指向待划分序列 r 的范围，取 low 所指元素为枢轴，即 pivot = r[low]。划分首先从 high 所指位置的元素起向前逐一搜索到第一个比 pivot 小的元素，并将其设置到 low 所指的位置；然后从 low 所指位置的元素起向后逐一搜索到第一个比 pivot 大的元素，并将其设置到 high 所指的位置；不断重复上述两步直到 low = high 为止，最后将 pivot 设置到 low 与 high 共同指向的位置。

源码

package com.algorithm.sorting;/** * 快速排序 *  */public class Quicksort {    private static void QuickSort(int[] a, int low, int high) {        // 该方法接受三个参数，分别为待排序的数组，数组的低端下标，数组的高端下标        System.out.print("要排序的数组：");        for (int n = 0; n < a.length; n++) {            System.out.print(a[n] + "\t");        }        System.out.println("");        int i, j, temp;        // 定义变量temp,作为标准数据元素        if (low < high) {//保证数组下标正常            i = low;            j = high;            temp = a[i];            System.out.println("pivot="+temp);              // temp作为标准数据元素            while (i < j) {                while (i < j && a[j] > temp)                    j--;                // 从数组的右端扫描，并与标准数据元素temp比较，如果a[j]>temp,数据位置不变，继续向左端扫描                if (i < j) {                    // 数据元素a[j]<temp,则与a[i]交换,使小于temp的元素在temp的左边，并把i值加1，并从数组的左端向右端扫描                    a[i] = a[j];                    i++;                }                while (i < j && a[i] < temp)                    i++;                // 数组的左端向右端扫描                if (i < j) {                    a[j] = a[i];                    j--;                    // 数据元素a[i]>emp,则与a[j]交换,使大于temp的元素在temp的右边边，并把j值减1，并从数组的由端向左端扫描                    a[i] = a[j];                }            }            a[i] = temp;//          System.out.println(i);              QuickSort(a, low, i - 1);            // 对左端子集合进行递归            QuickSort(a, i + 1, high);            // 对右端子集合进行递归        }    }    public static void main(String[] args) {        int array[] = { 99, 30,20 ,-1,100,53 };        QuickSort(array, 0, 5);        System.out.print("最终排序结果：");        for (int i = 0; i < array.length; i++) {            System.out.print(array[i] + " ");        }    }}

源码解析

首先看排序的过程：
pivot枢轴元素，也可以理解为数组中间大小元素

要排序的数组：99   30  20  -1  100 53  //原始数组pivot=99要排序的数组：53   30  20  -1  99  100  //第一次交换后数组pivot=53要排序的数组：-1   30  20  53  99  100 //第二次交换后数组pivot=-1要排序的数组：-1   30  20  53  99  100 //第三次交换后数组要排序的数组：-1   30  20  53  99  100 pivot=30要排序的数组：-1   20  30  53  99  100 //第四次交换后数组要排序的数组：-1   20  30  53  99  100 要排序的数组：-1   20  30  53  99  100 要排序的数组：-1   20  30  53  99  100 最终排序结果：-1 20 30 53 99 100 

算法原理

　假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一躺快速排序的算法是：
1）、设置两个变量I、J，排序开始的时候I：=1，J：=N；
2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；
3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；
4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；
5）、重复第3、4步，直到I=J；
例如：待排序的数组A的值分别是：（初始关键数据X：=49）
49 38 65 97 76 13 27
进行第一次交换后：
27 38 65 97 76 13 49
进行第二次交换后：
27 38 49 97 76 13 65
进行第三次交换后：
27 38 13 97 76 49 65
进行第四次交换后：
27 38 13 49 76 97 65
此时再执行第三不的时候就发现I=J，从而结束一躺快速排序，那么经过一躺快速排序之后的结果是：
27 38 13 49 76 97 65，即所以大于49的数全部在49的后面，所以小于49的数全部在49的前面。

效率分析

时间效率：快速排序算法的运行时间依赖于划分是否平衡，即根据枢轴元素 pivot 将序列划分为两个子序列中的元素个数，而划分是否平衡又依赖于所使用的枢轴元素。下面我们在不同的情况下来分析快速排序的渐进时间复杂度。
快速排序的最坏情况是每次进行划分时，在所得到的两个子序列中有一个子序列为空。
此时，算法的时间复杂度T(n) = T p (n) + T(n-1)，其中T p (n)是对具有n个元素的序列进行划分所需的时间，由以上划分算法的过程可以得到T p (n) = Θ(n)。由此，T(n) =Θ(n) + T(n-1) =Θ(n2)。
在快速排序过程中，如果总是选择r[low]作为枢轴元素，则在待排序序列本身已经有序或逆向有序时，快速排序的时间复杂度为Ο(n 2 )，而在有序时插入排序的时间复杂度为Ο(n)。
快速排序的最好情况是在每次划分时，都将序列一分为二，正好在序列中间将序列分成长度相等的两个子序列。此时，算法的时间复杂度T(n) = T p (n) + 2T(n/2)，由于T p (n) = Θ(n)，所以T(n) = 2T(n/2) +Θ(n)，由master method知道T(n) = Θ(n log n)。
在平均情况下，快速排序的时间复杂度 T(n) = kn ㏑ n，其中 k 为某个常数，经验证明，在所有同数量级的排序方法中，快速排序的常数因子 k 是最小的。因此就平均时间而言，快速排序被认为是目前最好的一种内部排序方法。
快速排序的平均性能最好，但是，若待排序序列初始时已按关键字有序或基本有序，则快速排序蜕化为起泡排序，其时间复杂度为O(n2)。为改进之，可以采取随机选择枢轴元素pivot的方法，具体做法是，在待划分的序列中随机选择一个元素然后与r[low]交换，再将r[low]作为枢轴元素，作如此改进之后将极大改进快速排序在序列有序或基本有序时的性能，在待排序元素个数n较大时，其运行过程中出现最坏情况的可能性可以认为不存在。

空间效率：虽然从时间上看快速排序的效率优于前述算法，然而从空间上看，在前面讨
论的算法中都只需要一个辅助空间，而快速排序需要一个堆栈来实现递归。若每次划分都将
序列均匀分割为长度相近的两个子序列，则堆栈的最大深度为 log n，但是，在最坏的情况
下，堆栈的最大深度为 n。

总结：

快速排序是快速排序被认为是目前最好的一种内部排序方法。有必要学习掌握的。写博客是为了帮助开发者学习使用技术，同时巩固自己所学技术。如果此篇博客有助于您的学习，那是我的荣幸！如果此篇博客有任何瑕疵，请多多指教!在此感谢您的学习和指教！