数据结构-快速排序Java实现

一、引言

    快速排序的核心思想是选择一个基准元素，将数组分为两个子数组：一个包含所有小于基准的元素，一个包含所有大于基准的元素。然后，递归地对这两个子数组进行排序，最终合并以得到已排序的数组。这个算法的关键在于快速地将数组分成两部分，从而减少排序问题的规模。

二、算法步骤

快速排序的基本步骤如下：

1. 选择基准元素：从数组中选择一个基准元素。通常，可以选择数组的第一个元素、最后一个元素或中间元素作为基准。
2. 分区：将数组中的元素重新排列，将小于基准的元素移到基准的左边，将大于基准的元素移到基准的右边，基准元素位于中间。
3. 递归：对基准左边和右边的子数组分别应用快速排序。
4. 合并：已排序的子数组与基准元素合并为最终排序的数组。

三、原理演示

假设我们有以下整数数组：
[64, 34, 25, 12, 22, 11, 90]

第一步：选择基准元素

    在快速排序的第一步，我们需要选择一个基准元素。通常情况下，可以选择数组中的第一个元素。在这个例子中，我们选择基准元素为 64。

第二步：分区（Partition）

    在分区步骤中，我们将数组中的元素重新排列，将小于基准的元素移到基准的左边，将大于基准的元素移到基准的右边，基准元素本身位于中间。这一步的目标是将基准元素放在它在排序后应该处于的位置。
    我们从数组的左边和右边分别开始，分别找到一个比基准元素大的元素和一个比基准元素小的元素。
    交换这两个元素，将较小的元素放在左边，较大的元素放在右边。继续这个过程，直到左右指针相遇。
在这个例子中，经过分区步骤，数组变为：
[34, 25, 12, 22, 11, 64, 90]
此时，基准元素 64 处于正确的位置。

第三步：递归

    在递归步骤中，我们将分区得到的两个子数组分别应用快速排序。对于左边的子数组 [34, 25, 12, 22, 11] 和右边的子数组 [90]，我们分别进行快速排序。
重复这个过程，递归地将数组分解成更小的子问题。

第四步：合并

    在合并步骤中，已排序的子数组与基准元素合并为最终排序的数组。在这个例子中，左边的子数组 [11, 12, 22, 25, 34] 与右边的子数组 [90] 合并成了整个已排序的数组。
最终，整个数组变为：
[11, 12, 22, 25, 34, 64, 90]

这就完成了快速排序的过程。

四、代码实战

下面是使用Java编写的快速排序算法示例：

public class QuickSort {
    
    public static void main(String[] args) {
    
        int[] arr = {
    64, 34, 25, 12, 22, 11, 90};

        System.out.println("原始数组：");
        printArray(arr);

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

        System.out.println("排序后的数组：");
        printArray(arr);
    }

    public static void quickSort(int[] arr, int low, int high) {
    
        if (low < high) {
    
            int pivot = partition(arr, low, high);
            quickSort(arr, low, pivot - 1);
            quickSort(arr, pivot + 1, high);
        }
    }

    public 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++;
                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 value : arr) {
    
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

上述代码演示了快速排序的实现。它首先定义了一个包含整数数组的示例，然后调用 quickSort 方法来对数组进行排序。quickSort 方法使用递归来排序数组，而 partition 方法用于将数组分成两个子数组并返回基准元素的索引。

五、结论

我们一起来总结一下：

1. 快速排序的时间复杂度在平均情况下为O(nlogn)，而在最坏情况下为O(n^{2)。这主要取决于递归树的深度和每个递归调用中比较关键字的次数。在最坏情况下，即待排序的序列是正序或逆序，需要n-1次递归调用，且每次划分需要经过n-i次关键字比较，因此比较次数为(n-1)+…+3+2+1=n(n-1)/2，其时间复杂度为O(n}2)。在平均情况下，通过优化选取枢轴的方法（如三数取中法），可以减少递归次数和关键字的比较次数，从而使时间复杂度降为O(nlogn)。
2. 快速排序的空间复杂度为O(logn)，这是由于递归调用的需要。在最坏情况下，递归树的深度为n，因此需要O(n)的空间来存储递归过程中的临时变量。但在平均情况下，由于递归次数减少，需要的空间复杂度为O(logn)。
3. 快速排序算法的稳定性是指相同元素的相对位置在排序后不会改变。然而，由于关键字的比较和交换是跳跃进行的，因此快速排序算法是一种不稳定的排序方法。
4. 快速排序算法有许多优化方法，如选取枢轴的优化、处理重复元素的优化等。其中选取枢轴的优化是采用三数取中法：取左端、中间、右端三个数进行排序，取中间的那个数作为枢轴，这样中间的数位于中间值的可能性就大大提高了。

点赞收藏，富婆包养