快速排序：原理、实现、优化与应用

快速排序：原理、实现、优化与应用

在 Java 编程的算法领域中，快速排序是一种高效且广泛应用的排序算法。它凭借独特的思想和出色的平均性能，在众多排序算法中脱颖而出。接下来，我们将深入探讨快速排序的各个方面。

一、快速排序的基本概念

快速排序是一种基于分治策略的排序算法。它的基本思想是通过选择一个基准元素，将数组分为两部分，使得左边部分的元素都小于等于基准元素，右边部分的元素都大于等于基准元素，然后递归地对左右两部分进行排序，最终使整个数组有序。

二、快速排序的原理

1. 选择基准元素：从数组中选择一个元素作为基准（pivot），常见的选择方式有随机选择、选择数组的第一个元素或中间元素等。

1. 分区操作：设置两个指针，一个从数组的起始位置开始（left），一个从数组的末尾位置开始（right）。通过比较元素与基准元素的大小，将小于基准的元素交换到左边，大于基准的元素交换到右边，直到两个指针相遇，此时基准元素处于正确的位置，数组被分为左右两部分。

1. 递归排序：对左右两部分子数组，分别重复上述选择基准元素和分区操作，直到子数组的长度为 1 或 0，因为长度为 1 或 0 的数组天然有序。

三、Java 代码实现

public class QuickSort {

    public static void main(String[] args) {

        int[] array = {
            64,
            34,
            25,
            12,
            22,
            11,
            90
        };

        quickSort(array, 0, array.length - 1);

        for (int num: array) {

            System.out.print(num + " ");

        }

    }

    public static void quickSort(int[] arr, int low, int high) {

        if (low < high) {

            int pi = partition(arr, low, high);

            // 递归地对左右两部分进行排序

            quickSort(arr, low, pi - 1);

            quickSort(arr, pi + 1, high);

        }

    }

    private static int partition(int[] arr, int low, int high) {

        int pivot = arr[high];

        int i = (low - 1);

        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;

            }

        }

        // 交换arr[i + 1]和arr[high]

        int temp = arr[i + 1];

        arr[i + 1] = arr[high];

        arr[high] = temp;

        return i + 1;

    }

}

在上述代码中，quickSort方法负责递归调用进行排序，partition方法实现了分区操作，将数组分为左右两部分，并返回基准元素的正确位置。

四、性能分析

1. 时间复杂度：

• • 平均情况：快速排序的平均时间复杂度为 O (n log n)，因为每次分区都能大致将数组分为两部分，递归深度为 log n，每层的时间复杂度为 O (n)。

• • 最坏情况：当选择的基准元素总是数组中的最大或最小元素时，比如数组已经有序，快速排序的时间复杂度会退化到 O (n²)，因为每次分区只能减少一个元素。

1. 空间复杂度：快速排序在递归调用过程中需要用到栈空间，平均情况下栈的深度为 log n，所以空间复杂度为 O (log n)。但在最坏情况下，栈深度为 n，空间复杂度为 O (n)。

五、优化策略

1. 随机选择基准元素：为了避免在数组有序或接近有序时的最坏情况，选择基准元素时采用随机选择的方式，减少出现极端情况的概率。

private static int partition(int[] arr, int low, int high) {

    // 随机选择基准元素

    int randomIndex = low + (int)(Math.random() * (high - low + 1));

    int temp = arr[randomIndex];

    arr[randomIndex] = arr[high];

    arr[high] = temp;

    int pivot = arr[high];

    int i = (low - 1);

    for (int j = low; j < high; j++) {

        if (arr[j] < pivot) {

            i++;

            // 交换arr[i]和arr[j]

            temp = arr[i];

            arr[i] = arr[j];

            arr[j] = temp;

        }

    }

    // 交换arr[i + 1]和arr[high]

    temp = arr[i + 1];

    arr[i + 1] = arr[high];

    arr[high] = temp;

    return i + 1;

}

1. 三数取中选择基准元素：选择数组的第一个元素、中间元素和最后一个元素，取这三个元素的中间值作为基准元素，这样能在一定程度上提高基准元素的代表性。

private static int getPivotIndex(int[] arr, int low, int high) {

    int mid = low + (high - low) / 2;

    if ((arr[low] <= arr[mid] && arr[mid] <= arr[high]) || (arr[high] <= arr[mid] && arr[mid] <= arr[low])) {

        return mid;

    } else if ((arr[mid] <= arr[low] && arr[low] <= arr[high]) || (arr[high] <= arr[low] && arr[low] <= arr[mid])) {

        return low;

    } else {

        return high;

    }

}

private static int partition(int[] arr, int low, int high) {

    int pivotIndex = getPivotIndex(arr, low, high);

    int temp = arr[pivotIndex];

    arr[pivotIndex] = arr[high];

    arr[high] = temp;

    int pivot = arr[high];

    int i = (low - 1);

    for (int j = low; j < high; j++) {

        if (arr[j] < pivot) {

            i++;

            // 交换arr[i]和arr[j]

            temp = arr[i];

            arr[i] = arr[j];

            arr[j] = temp;

        }

    }

    // 交换arr[i + 1]和arr[high]

    temp = arr[i + 1];

    arr[i + 1] = arr[high];

    arr[high] = temp;

    return i + 1;

}

1. 小规模数组使用插入排序：当子数组的规模较小时，插入排序在局部数据上的性能优于快速排序。可以在递归时设置一个阈值，当子数组长度小于阈值时，使用插入排序。

private static final int INSERTION_SORT_THRESHOLD = 16;

public static void quickSort(int[] arr, int low, int high) {

    if (low < high) {

        if (high - low + 1 <= INSERTION_SORT_THRESHOLD) {

            insertionSort(arr, low, high);

            return;

        }

        int pi = partition(arr, low, high);

        // 递归地对左右两部分进行排序

        quickSort(arr, low, pi - 1);

        quickSort(arr, pi + 1, high);

    }

}

private static void insertionSort(int[] arr, int low, int high) {

    for (int i = low + 1; i <= high; i++) {

        int key = arr[i];

        int j = i - 1;

        while (j >= low && arr[j] > key) {

            arr[j + 1] = arr[j];

            j = j - 1;

        }

        arr[j + 1] = key;

    }

}

六、与其他排序算法的对比

1. 与归并排序相比：快速排序和归并排序的平均时间复杂度都是 O (n log n)，但快速排序是原地排序，空间复杂度平均为 O (log n)，而归并排序需要额外的空间来合并数组，空间复杂度为 O (n)。在平均情况下，快速排序的性能略优于归并排序，但在最坏情况下，归并排序的性能更稳定。

1. 与希尔排序相比：希尔排序的时间复杂度依赖于步长序列，在某些情况下性能不如快速排序稳定。快速排序的平均时间复杂度为 O (n log n)，在处理大规模数据时通常比希尔排序更高效。

快速排序以其高效的平均性能和原地排序的特性，在 Java 编程中得到了广泛应用。通过对其原理、实现和优化的深入理解，我们能够更好地在实际项目中运用它来处理各种排序需求。如果你对快速排序还有其他疑问，比如在不同数据分布下的性能表现，欢迎随时交流。

​ 如果需要详细的动态排序过程，可以参考下面这个网站，这个网站能看到排序的动态过程

排序（冒泡排序，选择排序，插入排序，归并排序，快速排序，计数排序，基数排序） - VisuAlgohttps://visualgo.net/zh/sorting