快速排序的实现及其优化

什么是快速排序

• 快速排序是常规排序中速度最快的，也是面试中经常会问的

  • 快速排序最好的时间复杂度是 O(nLogn)，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来,所以快速排序通常比其他 Ο(nLogn) 算法更快

• 算法的思想也是比较简单直观的，就是给要排序的元素找合适的位置，把比这个元素大的放右边，小的放左边，就找到了该元素的位置，运用到了分治的思想

• 是不稳定的排序算法

• 快速排序的最坏运行情况是 O(n²)，比如说顺序数列的快排，但它的平摊期望时间是 O(nLogn)，且 O(nLogn) 记号中隐含的常数因子很小，比复杂度稳定等于 O(nLogn) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。

递归实现

//普通递归处理
public static void Sort(int[] arr, int left, int right) {
    if (left >= right) return;
    //将排序后的元素确定了的位置作为下一轮排序的边界
    int pivot = move(arr, left, right);
    Sort(arr,left,pivot-1);
    Sort(arr,pivot+1,right);
}

快速排序的基础实现

• 从数列中挑出一个元素，称为 “基准”（pivot）
• 重新排序数列，把所有元素比基准值小的摆放在基准前面。在这个分区退出之后，该基准就处于数列的中间位置。
• 递归地把小于基准值元素的子数列排序；
• 常规算法实现的基准为数组的最后一个元素或第一个元素，这里取第一个元素为基准

//基础快排
public static int move(int[] arr, int leftBound, int rightBound) {
    // 设定基准值（pivot）
    int pivot = leftBound;
    //小于基准值的区域的左指针
    int left = pivot + 1;
    for (int i = left; i <= rightBound; i++) {
        //i位置的值小于基准值则移动到左边（left）
        if (arr[i] < arr[pivot]) {
            swap(arr, i, left);
            left++;
        }
    }
    swap(arr, pivot, left - 1);
    return left - 1;
}

双路快排的实现

• 双路快排是把数组分为了两个区域，一个大于基准区，一个小于基准区，速度比基础快排更快，但是在处理重复数组是依旧是效率不高

//小于基准的放左边，大于基准的放右边
public static int move(int[] arr, int leftBound, int rightBound) {
    //选数组最右作为基准值
    int pivot = arr[rightBound];
    int left = leftBound;
    int right = rightBound - 1;
    while (left <= right) {
        while (left <= right && arr[left] <= pivot) left++;
        while (left <= right && arr[right] > pivot) right--;
        if (left < right) swap(arr, left, right);
    }
    swap(arr, left, rightBound);
    return left;
}

• 这个实现是用双指针
• 时间复杂度：O(nLogn)
• 空间复杂度：O(Logn)

三路快排的实现

• 三路快排就是把数组分为三个区域，一个大于基准区，一个等于基准区，一个小于基准区

• 解决数组重复元素过多，减少多余的比较

//三路快排
public static int move(int[] arr, int leftBound, int rightBound) {
    //使用了三数取中，放在数组最左作为基准值
    int pivot = ThreeNumSelect(arr, leftBound, rightBound);
    //left指针用于记录小于基准值的区域
    int left = leftBound
    //right指针用于记录大于基准值的区域
    int right = rightBound;
    //mid指针用于记录等于基准值的区域，同时也是遍历的指针
    int mid = left + 1;
    while(mid <= right){
        if(arr[mid] < pivot){
            //小于基准值的就放在小于区，即left+1的位置，然后left++；
            swap(arr,mid,left+1);
            left++;
            mid++;
        }else if (arr[mid] > pivot){
            //大于基准值的就放在right的位置上，right--
            //此时mid位置上的不确定其大小，需要在下次循环时判断
            swap(arr,mid,right);
            right--;
        }else{
            //等于基准值的则放在mid区，mid++即可
            mid++;
        }
    }
    //最后交换基准和left的位置，当前left的值是小于基准值的
    swap(arr,leftBound,left);
    //返回基准值的位置，作为递归调用的边界值
    return left;
}

• 相当是三指针
• 时间复杂度：O(nLogn)
• 空间复杂度：O(Logn)

算法的优化

• 主要通过优化基准的选择来达到算法的优化，处理降序数组时优化明显

  • 采用三数选中，比如

    ​ 数组A = {6，1，3，4，6，7，9 }

    ​ 取三数分别是：6，4，9 将他们排序后取6作为基准

//三数取中
public static void ThreeNumSelect(int[] arr, int low, int high) {
    int mid = low + (high - low) / 2;
    //标记是否发生交换
    int flag = 0;
    // 下面两步保证了arr[high]是最大的
    if (arr[mid] > arr[high]) {
        swap(arr, mid, high);
    }
    if (arr[low] > arr[high]) {
        swap(arr, low, high);
    }
    // 将arr[low]和arr[mid]比较，让较小的在arr[low]的位置
    if (arr[low] > arr[mid]) {
        flag = 1;
        swap(arr, mid, low);
    }
    //数组中间值有发生交换位置的时候才执行
    //将中间值移到数组d一位
    if (flag == 1) swap(arr, mid, high);
}

• 当待排序的数列分割到一定大小时使用插入排序

  • 插入排序在处理样本小且基本有序的数组时效率最高

if (left - right + 1 < 10) {
    InsertSort(arr);
    return;
}

• 使用尾递归，减少栈的深度，可以处理更多的数据

//尾递归
while(left < right) {
    pivot = move(arr, left, right);
    Sort(arr, left, pivot - 1);
    left = pivot + 1;
}

• 使用位运算优化交换过程

//交换
public static void swap(int[] arrays, int i, int j) {
    //由于位运算如果操作同一块内存区域会将此区域抹成0
    if (i==j) return;
    arrays[i] = arrays[i] ^ arrays[j];
    arrays[j] = arrays[i] ^ arrays[j];
    arrays[i] = arrays[i] ^ arrays[j];
}