Python 算法高级篇：快速排序的优化算法

原创

小蓝枣 2023-12-15 09:14:04 ©著作权

文章标签 算法 python 排序算法快速排序算法快速排序 文章分类 Html/CSS 前端开发

©著作权归作者所有：来自51CTO博客作者小蓝枣的原创作品，请联系作者获取转载授权，否则将追究法律责任

Python 算法高级篇：快速排序的优化算法

引言
1. 快速排序的基本原理
2. 快速排序的优化技巧

2.1 随机选择基准
2.2 三分法
2.3 小数组使用插入排序

3. 性能比较
4. 结论

引言

在计算机科学中，排序是一个基本操作，而快速排序（ Quick Sort ）是最著名和广泛使用的排序算法之一。它是一种高效的、分治的排序算法，通过不断将问题分解成更小的子问题来实现排序。本文将介绍快速排序的基本原理，然后深入讨论一些优化技巧，以提高其性能。

😃😄 ❤️ ❤️ ❤️

1. 快速排序的基本原理

快速排序的基本思想是选择一个元素作为“基准”（ pivot ），将小于基准的元素移到基准的左边，将大于基准的元素移到基准的右边，然后递归地对左右两个子数组进行排序。

下面是一个简单的快速排序算法的 Python 实现：

def quick_sort(arr):
    if len(arr) <= 1:
        return arr

    pivot = arr[0]
    left = [x for x in arr[1:] if x <= pivot]
    right = [x for x in arr[1:] if x > pivot]

    return quick_sort(left) + [pivot] + quick_sort(right)

这个算法递归地将数组分为左右两部分，然后在左右子数组上继续排序。在最坏情况下，时间复杂度为 O ( n ^ 2 )，但在平均情况下，快速排序的时间复杂度为 O ( n log n )，这使它成为一种非常高效的排序算法。

2. 快速排序的优化技巧

尽管快速排序是一个高效的排序算法，但在某些情况下，它可能不够快。为了进一步提高性能，可以使用一些优化技巧。

2.1 随机选择基准

快速排序的性能高度依赖于选择的基准元素。如果每次都选择数组的最大或最小元素作为基准，会导致算法在某些情况下性能下降到 O ( n ^ 2 )。为了避免这种情况，可以随机选择基准元素，或者从数组中选择中位数作为基准。

以下是一个随机选择基准的优化：

import random

def quick_sort(arr):
    if len(arr) <= 1:
        return arr

    pivot = random.choice(arr)
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]

    return quick_sort(left) + middle + quick_sort(right)

2.2 三分法

传统的快速排序将数组分为两部分：小于基准和大于基准。但在实际应用中，有时会有大量等于基准的元素，这使得快速排序性能下降。一种改进是使用“三分法”：将数组分为小于、等于和大于基准的三部分，然后递归排序小于和大于部分。

以下是使用三分法的优化：

def quick_sort(arr):
    if len(arr) <= 1:
        return arr

    pivot = arr[0]
    less = [x for x in arr if x < pivot]
    equal = [x for x in arr if x == pivot]
    greater = [x for x in arr if x > pivot]

    return quick_sort(less) + equal + quick_sort(greater)

2.3 小数组使用插入排序

对于小数组，插入排序通常比快速排序更快，因为它的常数因子更小。因此，在递归的过程中，当子数组变得足够小的时候，可以切换到插入排序。

以下是一个结合插入排序的优化：

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

def quick_sort(arr, threshold=10):
    if len(arr) <= 1:
        return arr

    if len(arr) <= threshold:
        insertion_sort(arr)
        return arr

    pivot = arr[0]
    less = [x for x in arr if x < pivot]
    equal = [x for x in arr if x == pivot]
    greater = [x for x in arr if x > pivot]

    return quick_sort(less) + equal + quick_sort(greater)

3. 性能比较

为了演示这些优化技巧的性能，我们将使用不同大小的随机数组来对比未优化和优化后的快速排序。

import random
import timeit

arr = [random.randint(1, 1000) for _ in range(1000)]

# 未优化的快速排序
def quick_sort_original(arr):
    if len(arr) <= 1:
        return arr

    pivot = arr[0]
    left = [x for x in arr[1:] if x <= pivot]
    right = [x for x in arr[1:] if x > pivot]

    return quick_sort_original(left) + [pivot] + quick_sort_original(right)

# 测试未优化的快速排序
time_original = timeit.timeit(lambda: quick_sort_original(arr), number=100)

# 优化后的快速排序
def quick_sort_optimized(arr):
    if len(arr) <= 1:
        return arr

    pivot = random.choice(arr)
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]

    return quick_sort_optimized(left) + middle + quick_sort_optimized(right)

# 测试优化后的快速排序
time_optimized = timeit.timeit(lambda: quick_sort_optimized(arr), number=100)

print(f"未优化的快速排序平均耗时: {time_original:.6f} 秒")
print(f"优化后的快速排序平均耗时: {time_optimized:.6f} 秒")

这个示例生成一个包含 1000 个随机整数的数组，并分别测试未优化和优化后的快速排序的性能。优化后的版本通常会更快。