快速排序全面剖析：从原理到Java实现

齐朋
358 阅读5分钟

算法基础——快速排序

快速排序（QuickSort）是计算机科学中最经典的排序算法之一，广泛应用于各种排序任务，尤其是在面试中，常常会被提问。快速排序的高效性源自它的分治策略，其核心思想是通过选择一个基准值将数组分成左右两部分，然后递归地排序这两部分。今天我们将通过详细解析和Java代码示例，来帮助大家深入理解快速排序的实现原理。

一、快速排序的工作原理

快速排序的核心流程可以分为三个主要步骤：

  1. 选择基准值（Pivot）
    在快速排序中，首先要选择一个元素作为基准值，通常选择数组的第一个元素、最后一个元素，或者随机选择一个元素作为基准值。基准值的选择对快速排序的性能影响较大，通常情况下，我们希望选择一个较为“合适”的基准值，这样可以更好地平衡分割后的两个子数组的大小，避免最坏情况发生。

  2. 双指针法进行划分
    接下来，我们使用双指针法进行划分。我们定义两个指针：一个从数组的左端（头部）开始，另一个从右端（尾部）开始。然后，左指针向右移动，直到找到一个大于或等于基准值的元素；右指针向左移动，直到找到一个小于基准值的元素。若左指针小于右指针，就交换这两个元素的位置。这个过程一直进行，直到两个指针相遇，标志着基准值的正确位置已经找到。

  3. 递归排序左右两部分
    最后，我们将基准值放置在它最终的位置后，数组被划分为两个部分：左侧部分包含所有小于基准值的元素，右侧部分包含所有大于基准值的元素。然后，分别递归地对这两部分进行排序，直到每个部分只有一个元素为止，这时数组就是有序的。

二、快速排序的时间复杂度分析

  • 平均时间复杂度：O(n log n)
    在大多数情况下，快速排序的时间复杂度是 O(n log n)，其中 n 是数组的元素个数。每次划分操作将数组分成两部分，递归地进行排序，所以递归深度是 O(log n)，每一层递归处理的时间是 O(n)，因此平均时间复杂度为 O(n log n)。

  • 最坏时间复杂度：O(n²)
    快速排序的最坏情况发生在每次选择的基准值都非常“极端”，导致每次分割的数组都只有一个元素。这种情况通常出现在数组已经有序或逆序的情况下。此时，快速排序的时间复杂度退化为 O(n²)。

  • 空间复杂度：O(log n)
    快速排序是一个原地排序算法，不需要额外的存储空间。只需要一个栈空间来保存递归调用的状态。由于递归的最大深度是 O(log n)，因此空间复杂度为 O(log n)。

三、Java代码实现快速排序

下面是一个快速排序的Java实现代码：

public class QuickSort {
    
    // 快速排序入口
    public static void quickSort(int[] arr) {
        quickSortHelper(arr, 0, arr.length - 1);
    }
    
    // 快速排序递归函数
    private static void quickSortHelper(int[] arr, int low, int high) {
        if (low < high) {
            // 获取基准值的索引
            int pivotIndex = partition(arr, low, high);
            
            // 递归排序基准值左边的部分
            quickSortHelper(arr, low, pivotIndex - 1);
            
            // 递归排序基准值右边的部分
            quickSortHelper(arr, pivotIndex + 1, high);
        }
    }
    
    // 划分函数，返回基准值的最终位置
    private 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++;
                swap(arr, i, j);
            }
        }
        
        // 把基准值放到正确的位置
        swap(arr, i + 1, high);
        return i + 1; // 返回基准值的位置
    }
    
    // 交换数组中的两个元素
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
    // 测试代码
    public static void main(String[] args) {
        int[] arr = { 9, 7, 5, 11, 12, 2, 14, 3, 10, 6 };
        System.out.println("排序前:");
        printArray(arr);
        
        quickSort(arr);
        
        System.out.println("排序后:");
        printArray(arr);
    }
    
    // 打印数组
    private static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

四、运行结果

对于输入的数组 {9, 7, 5, 11, 12, 2, 14, 3, 10, 6}，运行上述代码的输出结果如下：

排序前:
9 7 5 11 12 2 14 3 10 6 
排序后:
2 3 5 6 7 9 10 11 12 14

五、总结

快速排序的实现通过选择基准值来分割数组，使用双指针法实现元素的交换，最终实现高效的排序。其优点是时间复杂度在大多数情况下为 O(n log n)，并且是原地排序，不需要额外的存储空间。理解和掌握快速排序不仅有助于你在面试中取得高分，还能够在实际的算法设计和实现中带来极大的帮助。

希望通过这篇文章和代码示例，能够帮助大家更好地理解和实现快速排序。在学习过程中，大家可以尝试不同的基准值选择策略（如随机选择基准值或选择中位数）来进一步优化性能，避免最坏情况的发生。

avatar
文章
阅读
粉丝