数据排序的艺术：快速排序及其优化之旅

快速排序：从基础到优化

快速排序是计算机科学中最著名的排序算法之一，由C. A. R. Hoare在1960年提出。它是一种分治法策略的应用，广泛用于各种场景，从数据库的查询优化到大数据处理，再到我们日常使用的文件排序。

快速排序的基本原理

快速排序的核心思想是选择一个元素作为基准（pivot），然后将数组分为两部分：一部分包含小于pivot的元素，另一部分包含大于pivot的元素。这个过程称为分区（partitioning）。接着，递归地对这两部分进行快速排序，直到整个数组有序。

时间复杂度和空间复杂度

快速排序的平均时间复杂度为O(n log n)，在大多数情况下表现出色。然而，在最坏的情况下，如当数组已经有序或者所有元素相等时，其时间复杂度会退化到O(n^2)。为了避免这种情况，通常会采用随机化或者其他策略来选择pivot。

在空间复杂度方面，快速排序是原地排序算法，它不需要额外的存储空间来创建数组的副本。但是，由于它是递归的，所以它的空间复杂度取决于递归调用栈的深度，最坏情况下为O(n)，平均情况下为O(log n)。

稳定性

快速排序不是一个稳定的排序算法。这意味着相等的元素在排序后可能会改变它们原始的顺序。

实现

普通版：快速排序

需要额外的空间复杂度

func QuickSort(arr []int) []int {if len(arr) <= 1 {return arr}pivot := arr[0]var left []intvar right []intfor i := 1; i < len(arr); i++ {if arr[i] < pivot {left = append(left, arr[i])} else {right = append(right, arr[i])}}return append(append(QuickSort(left), pivot), QuickSort(right)...)
}

这个版本引入了额外的空间 left、right 存储排序中间数据，我们可以通过原地排序进一步优化。

进阶版：原地快速排序

不需要额外的空间复杂度

func QuickSort(arr []int) {quickSort(arr, 0, len(arr)-1)
}func quickSort(arr []int, low, high int) {if low < high {// Partition the array by setting the position of the pivot elementpivotIndex := partition(arr, low, high)// Recursively sort elements before partition and after partitionquickSort(arr, low, pivotIndex-1)quickSort(arr, pivotIndex+1, high)}
}func partition(arr []int, low, high int) int {pivot := arr[high] // using the last element as the pivoti := low           // place for swappingfor j := low; j < high; j++ {// If current element is smaller than or equal to pivotif arr[j] <= pivot {arr[i], arr[j] = arr[j], arr[i] // swap arr[i] and arr[j]i++                             // increment index of smaller element}}arr[i], arr[high] = arr[high], arr[i] // swap the pivot element with the element at index ireturn i                              // return the partitioning index
}

进阶二：三位取中法

优化 pivot 取数，避免取数不合理导致的时间复杂度上升

func QuickSort(arr []int) {quickSort(arr, 0, len(arr)-1)
}func quickSort(arr []int, low, high int) {if low < high {// Choose pivot using median-of-three methodpivotIndex := medianOfThree(arr, low, high)arr[pivotIndex], arr[high] = arr[high], arr[pivotIndex] // Move pivot to end// Partition the array around the pivotpivotIndex = partition(arr, low, high)// Recursively sort elements before partition and after partitionquickSort(arr, low, pivotIndex-1)quickSort(arr, pivotIndex+1, high)}
}func partition(arr []int, low, high int) int {pivot := arr[high]i := lowfor j := low; j < high; j++ {if arr[j] <= pivot {arr[i], arr[j] = arr[j], arr[i]i++}}arr[i], arr[high] = arr[high], arr[i]return i
}func medianOfThree(arr []int, low, high int) int {mid := low + (high-low)/2if 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
}

进阶三：三项切分法

当有大量相同数据的时候，重复的部分无需排序，可以使用三项切分法进行优化

func QuickSort(arr []int) {quickSort(arr, 0, len(arr)-1)
}func quickSort(arr []int, low, high int) {if low < high {// Partition the array into three partslt, gt := threeWayPartition(arr, low, high)// Recursively sort elements before lt and after gtquickSort(arr, low, lt-1)quickSort(arr, gt+1, high)}
}func threeWayPartition(arr []int, low, high int) (int, int) {pivot := arr[low] // Choose the first element as pivotlt := low         // lt is the index for the last element less than pivotgt := high        // gt is the index for the first element greater than pivoti := low + 1      // Start from the element next to pivotfor i <= gt {if arr[i] < pivot {arr[lt], arr[i] = arr[i], arr[lt]lt++i++} else if arr[i] > pivot {arr[i], arr[gt] = arr[gt], arr[i]gt--} else {i++}}return lt, gt
}