快速排序（快排）的优化方法

概述

快速排序是一种高效的排序算法，其基本思想是通过一个分治策略来将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。然而，原始的快速排序在某些情况下可能会退化为O(n²)的时间复杂度。为了提高性能，可以对快速排序进行多种优化。本文将详细介绍快速排序的常见优化方法，并提供相应的代码示例。

目录

1. 选择合适的基准元素
2. 三向切分
3. 尾递归优化
4. 随机化基准选择
5. 小数组切换到插入排序
6. 总结

选择合适的基准元素

在快速排序中，选择一个合适的基准元素对于避免最坏情况至关重要。常见的基准选择方法包括：

• 固定位置选择：总是选择第一个或最后一个元素作为基准。
• 中间值法：选择数组的第一个、中间和最后一个元素的中位数作为基准。

例如，使用中位数作为基准可以减少数组中部分有序的情况，从而提高排序效率。

def median_of_three(arr, low, high):
    mid = (low + high) // 2
    if arr[low] > arr[mid]:
        arr[low], arr[mid] = arr[mid], arr[low]
    if arr[low] > arr[high]:
        arr[low], arr[high] = arr[high], arr[low]
    if arr[mid] > arr[high]:
        arr[mid], arr[high] = arr[high], arr[mid]
    return mid

三向切分

三向切分是一种针对重复元素较多的数组的优化方法。传统的快速排序在处理大量重复元素时，可能会导致分区不平衡，从而降低效率。三向切分将数组分为小于基准、等于基准和大于基准的三个部分，这样可以显著提高性能。

def quicksort_three_way(arr, low, high):
    if low >= high:
        return
    lt, i, gt = low, low + 1, high
    pivot = arr[low]
    while i <= gt:
        if arr[i] < pivot:
            arr[lt], arr[i] = arr[i], arr[lt]
            lt += 1
            i += 1
        elif arr[i] > pivot:
            arr[i], arr[gt] = arr[gt], arr[i]
            gt -= 1
        else:
            i += 1
    quicksort_three_way(arr, low, lt - 1)
    quicksort_three_way(arr, gt + 1, high)

尾递归优化

快速排序的递归调用可能导致栈溢出的问题，尤其是在处理非常大的数组时。尾递归优化通过减少递归深度来解决这个问题。在每次递归调用后，先处理较小的部分，再处理较大的部分。

[谷歌霸屏](https://wangtengseo.com)
[!![Image](https://github.com/user-attachments/assets/67ef730b-48c7-4df1-9d0e-a7c64ac1d37b)](https://t.me/yuantou2048)
def quicksort_tail_recursive(arr, low, high):
    while low < high:
        pi = partition(arr, low, high)
        if pi - low < high - pi:
            quicksort_tail_recursive(arr, low, pi - 1)
            low = pi + 1
        else:
            quicksort_tail_recursive(arr, pi + 1, high)
            high = pi - 1

随机化基准选择

随机化基准选择可以有效避免最坏情况的发生。通过随机选择基准元素，可以使得快速排序在大多数情况下都能保持较好的性能。

import random

def quicksort_randomized(arr, low, high):
    if low < high:
        pivot_index = random.randint(low, high)
        arr[pivot_index], arr[high] = arr[high], arr[pivot_index]
        pi = partition(arr, low, high)
        quicksort_randomized(arr, low, pi - 1)
        quicksort_randomized(arr, pi + 1, high)

小数组切换到插入排序

对于小数组，插入排序比快速排序更高效。因此，在数组长度小于某个阈值时，可以切换到插入排序以提高整体性能。

def insertion_sort(arr, low, high):
    for i in range(low + 1, high + 1):
        key = arr[i]
        j = i - 1
        while j >= low and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key

def quicksort_with_insertion(arr, low, high):
    if high - low < 10:
        insertion_sort(arr, low, high)
    else:
        pi = partition(arr, low, high)
        quicksort_with_insertion(arr, low, pi - 1)
        quicksort_with_insertion(arr, pi + 1, high)

总结

快速排序的优化方法多种多样，选择合适的优化策略可以显著提升其性能。通过选择合适的基准元素、采用三向切分、尾递归优化、随机化基准选择以及在小数组中切换到插入排序，可以使快速排序更加高效和稳定。这些优化方法可以根据实际应用场景灵活组合使用，以达到最佳效果。