Java中常用算法之快速排序算法

一.快速排序（Quick Sort）是一种高效的排序算法，采用分治法策略。它通过选择一个“基准”元素，将数组分成两部分，使得一部分的元素都小于基准，另一部分的元素都大于基准，然后递归地对这两部分进行排序。以下是用Java实现快速排序的代码及其详细讲解。

二.快速排序代码

public class QuickSort {

    public static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            // 找到分区点
            int pi = partition(array, low, high);

            // 递归排序左半部分
            quickSort(array, low, pi - 1);

            // 递归排序右半部分
            quickSort(array, pi + 1, high);
        }
    }

    private static int partition(int[] array, int low, int high) {
        // 选择最右边的元素作为基准
        int pivot = array[high];
        int i = low - 1; // i是小于基准的元素的最后一个索引

        for (int j = low; j < high; j++) {
            // 如果当前元素小于或等于基准
            if (array[j] <= pivot) {
                i++;
                // 交换array[i]和array[j]
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }

        // 交换基准元素和array[i+1]
        int temp = array[i + 1];
        array[i + 1] = array[high];
        array[high] = temp;

        return i + 1; // 返回分区点
    }

    public static void main(String[] args) {
        int[] array = {10, 7, 8, 9, 1, 5};
        System.out.println("Unsorted array:");
        printArray(array);

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

        System.out.println("Sorted array:");
        printArray(array);
    }

    private static void printArray(int[] array) {
        for (int value : array) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

三.详细讲解

• 分治法:

• 快速排序使用分治法，将数组分成两部分，分别排序。

2. 选择基准:

• 在partition方法中，选择最右边的元素作为基准（pivot）。

3. 分区过程:

• 初始化i为low - 1，表示小于基准的元素的最后一个索引。

• 遍历数组，将小于或等于基准的元素交换到i的右边。

• 最后，将基准元素与array[i+1]交换，使基准元素处于正确的位置。

4. 递归排序:

• quickSort方法递归地对基准左边和右边的子数组进行排序。

5. 时间复杂度:

• 快速排序的平均时间复杂度为O(n log n)，但在最坏情况下（如每次选择的基准都是最大或最小元素）为O(n²)。

• 空间复杂度:

• 快速排序的空间复杂度为O(log n)，因为递归调用栈的深度为log n。

• 不稳定性:

• 快速排序是不稳定的排序算法，因为相同元素的相对顺序可能会改变。

总结

快速排序是一种高效的排序算法，适合于大规模数据集的排序。它的平均时间复杂度为O(n log n)，但在最坏情况下为O(n²)。快速排序的不稳定性和最坏情况下的时间复杂度是其主要缺点。通过选择合适的基准（如随机选择）可以在一定程度上避免最坏情况。