排序算法（五）：快速排序-CSDN博客

快速排序（Quick Sort）是由C.A.R. Hoare在1960年提出的排序算法，因其平均情况下出色的性能成为了排序算法中最常用的一种。快速排序采用了分治策略，平均时间复杂度为 O(n log n)，在大多数情况下表现出色。本文将深入讲解快速排序的原理、Java实现、性能分析，并与其他排序算法做对比。

1. 快速排序的基本原理

快速排序是一种基于分治法（Divide and Conquer）的排序算法。它通过选择一个“基准元素”（pivot），将数组分成两部分，其中一部分比基准元素小，另一部分比基准元素大，然后递归地对两部分继续进行快速排序。

快速排序的步骤：

选择基准元素：从数组中选择一个元素作为基准（通常是第一个、最后一个或随机选择）。
分割操作：通过一趟排序将数组分成两部分，一部分比基准元素小，另一部分比基准元素大。返回基准元素的位置。
递归排序：递归地对基准元素左边和右边的子数组进行快速排序，直到子数组的大小为1或者空。

快速排序的图示

假设我们有一个数组 [9, 3, 7, 1, 5, 11, 4]，我们选择最后一个元素作为基准元素来进行排序：

排序步骤	数组状态	基准元素	分割位置
初始状态	[9, 3, 7, 1, 5, 11, 4]	4
第一次分割	[3, 1, 4, 9, 5, 11, 7]	4	3
第二次分割	[1, 3]	4
第三次分割	[5, 9, 7, 11]	9	5
递归结束	[1, 3, 4, 5, 7, 9, 11]

可以看到，每次分割将大问题（整个数组）分解为两个小问题（左右子数组），并且通过递归解决这些子问题，最终完成排序。

2. 快速排序的时间复杂度分析

快速排序的时间复杂度与基准元素的选择密切相关。我们来分别分析最优、最坏和平均情况。

2.1 最好情况

当每次选择的基准元素都能将数组完美地分成两半时，快速排序的时间复杂度为 O(n log n)。这是最理想的情况。

2.2 最坏情况

如果每次选择的基准元素是当前数组的最大或最小元素（即数组已经是有序的或者逆序的），快速排序将退化为冒泡排序，时间复杂度为 O(n^2)。这通常发生在我们每次选择数组的第一个或最后一个元素作为基准时。

2.3 平均情况

对于随机选择基准元素的情况，平均时间复杂度是 O(n log n)。实际应用中，快速排序往往表现得非常高效。

2.4 空间复杂度

快速排序的空间复杂度为 O(log n)。递归栈的深度通常是 O(log n)，因此需要 O(log n) 的额外空间。

时间复杂度总结

情况	时间复杂度	空间复杂度
最好情况	O(n log n)	O(log n)
最坏情况	O(n^2)	O(log n)
平均情况	O(n log n)	O(log n)

3. 快速排序的Java实现

3.1 基本实现

以下是一个标准的快速排序实现，通过递归地对数组进行分割排序：

public class QuickSort {
    // 快速排序的实现
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            // 获取分割点
            int pivotIndex = partition(arr, low, high);
            
            // 递归排序分割点两边的子数组
            quickSort(arr, low, pivotIndex - 1);  // 排序左半部分
            quickSort(arr, pivotIndex + 1, high); // 排序右半部分
        }
    }

    // 分割操作：返回基准元素的最终位置
    public static int partition(int[] arr, int low, int high) {
        int pivot = arr[high]; // 选择最后一个元素为基准
        int i = (low - 1); // i是分割点的索引

        // 遍历整个数组，进行分割
        for (int j = low; j < high; j++) {
            // 如果当前元素小于等于基准元素，则交换
            if (arr[j] <= pivot) {
                i++;
                // 交换arr[i]和arr[j]
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        
        // 将基准元素放到正确的位置
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        
        return i + 1;
    }

    // 打印数组
    public static void printArray(int[] arr) {
        for (int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = {9, 3, 7, 1, 5, 11, 4};
        System.out.println("排序前：");
        printArray(arr);

        quickSort(arr, 0, arr.length - 1);
        
        System.out.println("排序后：");
        printArray(arr);
    }
}

3.2 代码解释

quickSort：是快速排序的主方法，它使用递归来处理数组的左右子数组。
partition：是分割操作，用来选择基准元素，并将比基准小的元素放到左边，比基准大的元素放到右边，最终返回基准元素的位置。
printArray：打印数组的方法。

3.3 示例输出

排序前：
9 3 7 1 5 11 4 
排序后：
1 3 4 5 7 9 11

4. 快速排序的优化

虽然快速排序在平均情况下非常高效，但仍然存在一些可以优化的地方。以下是常见的优化方法：

4.1 随机选择基准元素

为了避免最坏情况的发生，我们可以通过随机选择基准元素来减少出现 O(n^2) 的概率。使用随机基准元素能够显著提高算法的稳定性。

4.2 小数组优化

对于小数组（如数组长度小于10），快速排序的性能会下降。此时我们可以考虑使用插入排序来代替快速排序，因为插入排序在小规模数据上更有效。

4.3 三路切分

在存在大量重复元素的情况下，快速排序可能会退化为 O(n^2)。此时，我们可以使用“三路切分”来优化排序过程。三路切分方法将数组分为三部分：小于基准、等于基准和大于基准，从而减少重复元素的处理。

5. 快速排序与其他排序算法的对比

我们将快速排序与其他常见的排序算法（如冒泡排序、选择排序、插入排序和归并排序）进行对比，看看它在不同场景下的表现：

排序算法	最好情况时间复杂度	最坏情况时间复杂度	平均时间复杂度	空间复杂度	稳定性
快速排序	O(n log n)	O(n^2)	O(n log n)	O(log n)	不稳定
冒泡排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定
选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
插入排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定
归并排序	O(n log n)	O(n log n)	O(n log n)	O(n)	稳定

5.1 总结

快速排序：对大规模数据集非常高效，平均时间复杂度为 O(n log n)，适用于数据量大的场景。由于其不稳定性，需要特别小心在需要稳定排序的场景下使用。
冒泡排序、选择排序和插入排序：这些算法的时间复杂度较高，适用于小数据集或已部分排序的数据。
归并排序：与快速排序相比，归并排序稳定性较好，但需要较大的空间，因此在内存有限的情况下，快速排序可能更优。