排序算法之快速排序

一、简单介绍

快速排序是基于分治思想的一种排序算法，分为两大步骤：划分和求解子问题。

划分

即在待排序的序列中任取一个元素作为轴心，一般取序列的第一个元素，比较好的做法是比较首尾和中间三个元素的值，取排在中间的数作为轴心数。得到轴心后就可以对序列进行划分，划分的规则是将小于轴心的数放一边，大于轴心的数放另一边，轴心放中间，这也是完成一趟快速排序的划分结果，此时轴心的元素已经完成归位，即已是最终位置。
假如序列需要从小到大排序，通常的划分过程是选择第一个元素作为轴心，定义前后两个指针，首先从后指针开始，向前移动寻找比轴心值小的数，将它与轴心值位置交换，然后切换为前指针，向后寻找比轴心值大的数，将它与轴心值位置交换，然后切回后指针，这样来回切换指针并交换元素，直到前后指针重叠，重叠的位置就是轴心的位置，这样就完成一趟划分。轴心就是划分点，轴心前的序列元素小于等于轴心值，轴心后的序列元素大于等于轴心值。

求解子问题

分别对划分得到的一个个子序列再进行递归划分，直到每个子序列只有一个元素或为空为止，即子问题已可判断有序为止

二、基本特性

稳定性：快速排序无法保证相等元素的相对位置不变，所以是非稳定排序算法
时间复杂度：O(nlog₂n)
空间复杂度：快速排序使用递归，空间复杂度取决于栈的大小，因此它的平均空间复杂度为O(log₂n)

三、算法实现

假如有[65, 35, 66, 80, 65, 15, 37, 86, 91, 25]这样一个序列，我们来根据快速排序的思想编写算法对它进行排序：

import java.util.Random;
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = new int[]{65, 35, 66, 80, 65, 15, 37, 86, 91, 25};
//        Random rand = new Random();
//        for (int i = 0; i < arr.length; i++) {
//            arr[i] = rand.nextInt(90)+10;
//        }
        printf(arr,0,-1,arr.length-1);
        quickSort(arr);
        printf(arr,0,-1,arr.length-1);

    }
    public static void quickSort(int[] arr){
        int start = 0;
        int end = arr.length-1;
        quickSort(arr,start,end);
    }


    public static void quickSort(int[] arr,int start,int end){
        if (start >= end){//一个元素的时候已有顺序
            return;
        }
        int i = start;//前指针
        int j = end;//后指针
        while (i < j){//当前后指针相等则完成一趟分区
            //以arr[i]为轴心，从后往前寻找小于轴心的值
            while (i < j && arr[i] <= arr[j]){//跳出循环条件：arr[j]小于轴心值
                j--;
            }
            if(i<j){//前后针未重叠，说明后指针寻找到小于轴心值的值
                //交换，将寻找到的值放到轴心i的位置
                int tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
                //i的位置的元素，已确定比轴心值小，即本趟已归位，跳过
                i++;
            }
            //切换为前指针，以arr[j]为轴心，从前往后寻找大于轴心的值
            while (i < j && arr[i] <= arr[j]){//跳出循环条件：arr[i]大于轴心值
                i++;
            }
            if(i<j){//前后针未重叠，说明前指针寻找到大于轴心值的值
                //交换，将寻找到的值放到轴心j的位置
                int tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
                //j的位置的元素已确定比轴心值大，即本趟已归位，跳过
                j--;
            }
        }
//        printf(arr,start,i,end);
        //本趟分区完成，即轴心已全局归位，进入子序列的分区
        //递归小于轴心值的序列
        quickSort(arr,start,i-1);
        //递归大于轴心值的序列
        quickSort(arr,i+1,end);
    }
    //打印
    private static void printf(int[] arr,int start,int mid,int end){
        StringBuffer result = new StringBuffer();
        for (int i = 0; i < arr.length; i++) {
            if (i == start){
                result.append("[");
            }
            if (i == mid){
                result.append("{").append(arr[i]).append("}");
            }else {
                result.append(arr[i]);
            }
            if (i == end) {
                result.append("]");
            };
            result.append(", ");
        }
        result.setLength(result.length()-2);
        System.out.println(result);
    }
}

四、过程分析

未排序序列

[65, 35, 66, 80, 65, 15, 37, 86, 91, 25]

第1趟，选择65为轴心

[25, 35, 37, 15, 65, {65}, 80, 86, 91, 66]

第2趟，处理子问题[25, 35, 37, 15, 65]，选择25为轴心

[15, {25}, 37, 35, 65], 65, 80, 86, 91, 66

第3趟，处理子问题[37, 35, 65]，选择37为轴心

15, 25, [35, {37}, 65], 65, 80, 86, 91, 66

第4趟，处理子问题[80, 86, 91, 66]，选择80为轴心

15, 25, 35, 37, 65, 65, [66, {80}, 91, 86]

第5趟，处理子问题[91, 86]，选择91为轴心

15, 25, 35, 37, 65, 65, 66, 80, [86, {91}]

最终结果

[15, 25, 35, 37, 65, 65, 66, 80, 86, 91]