快速排序算法原理详解

快速排序算法是冒泡排序算法的一种改进，采用“分而治之”的思想，把大的拆分成小的，再把小的拆分成更小的。如：对于一组待排的记录，通过一趟排序后，将原序列分成两部分，其中前一部分的所有记录均比后一部分的所有记录小，然后再依次对前后两部分的记录进行快速排序，递归该过程，直到序列中的所有记录均有序为止。
具体而言，其算法步骤如下：
（1） 分解。将输入的序列a[m…n]划分成两个非空子序列a[m…k]和a[k+1…n]，使a[m…k]中任一元素的值不大于a[k+1…n]中的任一元素。
（2） 递归求解。通过递归调用快速排序算法分别对a[m…n]和a[k+1…n]进行排序。
（3） 合并。由于对分解出的两个子序列的排序是就地进行的，所以在a[m…k]和a[k+1…n都排好序后不需要执行任何计算array[m…n]就已排好序。
以数组{38,65,97,76,13,27,49}为例：
第一趟选取的关键字是38，则对应的，第一趟排序的结果是：[27 13] 38 [76 97 65 49]；
第二趟排序：
对于38左侧部分[27 13]进行快速排序，选取的关键字是27，排序结果是[13] 27，
对于28右侧部分[76 97 65 49]进行快速排序，选取的关键字是76，排序结果是[49 65] 76 [97]，
因此，第二趟排序的结果是[13] 27 [49 65] 76 [97]
第三趟排序：
对于27左侧部分[13]，只剩一个元素，则无需排序，同时，27右侧没有元素
对于76左侧元素排序[49 65]，进行快速排序，选取关键字为49，排序结果为49 [65]
对于76右侧的元素[97]，只有一个元素，则无需排序，
因此，第三趟排序的结果是13 27 49 [65] 76 97
而最终的排序结果是13 27 49 65 76 97
相对应的代码实现如下：
public class Test {
public static void main(String[] args){
int[] a = {38,65,97,76,13,27,49};
quickSort(a);
for (int i = 0; i < a.length; i ++){
System.out.print( a[i] + “\t” );
}
}

private static void quickSort(int[] a) {
    sort(0,a.length-1,a);
}

private static void sort(int low, int high, int[] a) {
    if (low >= high){
        return;
    }
    int i = low;
    int j = high;
    int index = a[i];
    while(i < j){
        while(i < j && a[j] >= index){
            j--;
        }
        if (i < j){
            a[i++] = a[j];
        }
        while(i < j && a[i] <= index){
            i++;
        }
        if (i < j){
            a[j--] = a[i];
        }
    }
    a[i] = index;
    sort(low,i-1,a);
    sort( i+1,high,a );
}

}

以上是对快速排序算法的分析，对于快速排序算法复杂度分析如下：
（1） 最好的时间复杂度。最好的情况是每次区间划分的结果都是关键字左右两边的序列长度相等或者相差为1，即选择的关键字为待排记录中的中间值，此时，进行的比较次数总共为nlogn，即，最好的时间复杂度为O(nlogn)
（2） 最坏时间复杂度。最坏情况是每次区间划分的结果都是关键字的左边或者右边，而另一边区间中的待排记录仅比排序前少了一个，即选择的关键字是待排记录中的最小值或者最大值，总共需要比较的次数为n(n-1)/2，所以，在最坏情况下快速排序的时间复杂度为O(n*n)。
（3） 平均时间复杂度。快速排序的平均时间复杂度为O(nlogn)。
快速排序具有不稳定性，待排记录长度较大时，比较好