快排序解读

news2024/12/28 6:22:54

排序算法是计算机科学中不可或缺的一部分，它们在各种数据处理场景中发挥着关键作用。在众多排序算法中，快速排序以其高效的性能和简洁的实现成为了许多程序员的首选。今天，我们就来深入剖析快速排序算法，了解其原理、实现方式以及应用。

一、快速排序的原理

快速排序的基本思想是采用分治法（Divide and Conquer）来将一个数组排序。它选择一个元素作为“基准”（pivot），通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准小，另一部分的所有数据都比基准大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
在这里插入图片描述

二、快速排序的实现

快速排序的实现主要包括三个步骤：选择基准、划分数组和递归排序。

选择基准：通常可以选择数组的第一个元素、最后一个元素或者随机选择一个元素作为基准。
划分数组：将数组划分为两部分，使得一部分的元素都小于基准，另一部分的元素都大于基准。这通常通过遍历数组并交换元素来实现。
递归排序：对划分后的两部分数组递归地应用快速排序算法。

下面是一个使用Python实现的快速排序示例：

def quicksort(arr):  
    if len(arr) <= 1:  
        return arr  
    pivot = arr[len(arr) // 2]  
    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 quicksort(left) + middle + quicksort(right)  
  
# 示例  
arr = [3,6,8,10,1,2,1]  
print(quicksort(arr))  # 输出: [1, 1, 2, 3, 6, 8, 10]

在这个实现中，我们选择了数组的中间元素作为基准，并使用列表推导式来创建小于、等于和大于基准的元素的子列表。然后，我们递归地对左右两个子列表进行快速排序，并将结果合并起来。

三、快速排序的性能与优化

快速排序的平均时间复杂度为O(n log n)，但在最坏情况下，当输入数组已经有序或逆序时，时间复杂度会退化为O(n^2)。为了避免最坏情况的发生，可以采取一些优化措施，如随机选择基准、使用三数取中等方法来选择更好的基准。

此外，快速排序的空间复杂度为O(log n)（递归调用栈），但在原地排序的版本中，空间复杂度可以优化到O(1)。

1. 随机选择基准
随机选择基准可以减少输入数据已经部分有序时对算法性能的影响。Python中的random.choice函数可以用来从列表中随机选择一个元素作为基准。

import random  
  
def partition(arr, low, high):  
    # 随机选择一个基准  
    pivot_index = random.randint(low, high)  
    arr[pivot_index], arr[high] = arr[high], arr[pivot_index]  # 将基准元素放到末尾  
    pivot = arr[high]  
    i = low - 1  # 指向小于基准的元素的指针  
    for j in range(low, high):  
        if arr[j] <= pivot:  
            i += 1  
            arr[i], arr[j] = arr[j], arr[i]  
    arr[i + 1], arr[high] = arr[high], arr[i + 1]  # 将基准元素放到正确的位置  
    return i + 1  
  
def quicksort(arr, low, high):  
    if low < high:  
        pi = partition(arr, low, high)  
        quicksort(arr, low, pi - 1)  
        quicksort(arr, pi + 1, high)  
  
# 示例  
arr = [3, 6, 8, 10, 1, 2, 1]  
n = len(arr)  
quicksort(arr, 0, n - 1)  
print("Sorted array is:", arr)

2. 使用三数取中法选择基准
三数取中法是从待排序序列的首、尾和中间三个元素中选择一个中值作为基准。这种方法可以尽量避免输入数据已排序或逆序时造成的性能下降。

def median_of_three(arr, low, mid, high):  
    if arr[low] > arr[mid]:  
        arr[low], arr[mid] = arr[mid], arr[low]  
    if arr[mid] > arr[high]:  
        arr[mid], arr[high] = arr[high], arr[mid]  
    if arr[low] > arr[mid]:  
        arr[low], arr[mid] = arr[mid], arr[low]  
    return arr[mid]  
  
def partition(arr, low, high):  
    mid = (low + high) // 2  
    pivot = median_of_three(arr, low, mid, high)  
    arr[mid], arr[high] = arr[high], arr[mid]  # 将基准元素放到末尾  
    i = low - 1  # 指向小于基准的元素的指针  
    for j in range(low, high):  
        if arr[j] <= pivot:  
            i += 1  
            arr[i], arr[j] = arr[j], arr[i]  
    arr[i + 1], arr[high] = arr[high], arr[i + 1]  # 将基准元素放到正确的位置  
    return i + 1  
  
def quicksort(arr, low, high):  
    if low < high:  
        pi = partition(arr, low, high)  
        quicksort(arr, low, pi - 1)  
        quicksort(arr, pi + 1, high)  
  
# 示例  
arr = [3, 6, 8, 10, 1, 2, 1]  
n = len(arr)  
quicksort(arr, 0, n - 1)  
print("Sorted array is:", arr)