Java快速排序

快速排序是一种高效的排序算法，他的基本思想是通过不断地取一个基准元素，将数组分割成两个子数组，然后对子数组进行分别的排序，这个过程递归地执行，直到整个数组有序。

具体步骤：

1. 选择基准元素：从数组中选择一个基准元素，这可以是数组种得任意一个元素，但通常选择第一个或者最后一个元素。
2. 分割数组：将数组中小于基准元素的元素放在基准元素的左边，大于基准元素的放在右边，基准元素此时已经在正确位置。例如：[10,28,5,30,29,98,80]这个数组，我们取10做为基准元素，第一次排序后应该是这样的[5,28,10,30,29,98,80],这样就从10分割了两个左右两边的数组，在分别从左右两个数组取基准元素，重复之前的操作[5,28,10,30,29,98,80]。
3. 递归：对基准元素左右的两个子数组分别进行快速排序。重复上述步骤，直到每个子数组只有一个元素，即数组有序。

        例如：[10,28,5,30,29,98,80]这个数组，我们取10做为基准元素，

        第一次排序后应该是这样的[5,28,10,30,29,98,80],这样就从10分割了两个左右两边的数组，在分别从左右两个数组取基准元素，重复之前的操作[5,28,10,30,29,98,80]。

        第二次排序[5,28,10,30,29,98,80]，左边数组取5，右边数组取30做为基准元素进行排序[5,28,10,29,30,98,80]。

        第三次排序，30左边就只有29一个元素，一个元素是有序不进行排序，就只剩下右边98，80两个元素，取98做为基准元素排序，[5,28,10,29,30,98,80]，排序完成后[5,28,10,29,30,98,80]

上代码：

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) {
            // 获取分区点的索引，arr[pivotIndex] 已经在正确的位置上
            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;
        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 num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

在这个例子中，quickSort 方法负责递归调用，partition 方法用于分割数组，并返回分区点的索引。快速排序的核心在于选取合适的基准元素，通过分割和递归的方式实现排序。

总结一下：

想象一下你手里有一堆乱序的扑克牌，现在你想把它们从小到大排好序。

1. 选择一张牌作为基准： 先从这堆牌中选择一张作为基准（比如说最后一张牌）。这张基准牌相当于这一轮排序的关键点。

2. 分两拨： 把其他的牌和这张基准牌比较大小。如果比基准牌小，就放到基准牌的左边；如果比基准牌大，就放到右边。

3. 左右分别再来： 这样，你手里的牌就被分成了左边比基准牌小的一堆和右边比基准牌大的一堆。而且基准牌已经在正确的位置上了。

4. 递归： 然后，你分别对左边和右边的两堆牌进行同样的操作。也就是说，每一堆牌都会有一个新的基准牌，再次进行分堆和比较。

5. 递归，递归，递归： 这个过程一直持续下去，每次递归都会让一张牌找到它应该在的位置。最终，所有的牌都找到了它们正确的位置，整个牌堆就有序了。

总的来说，快速排序就像是一个不断缩小问题规模的过程。每一轮都找一个基准，把问题分解成两个子问题，然后对子问题进行递归处理。这种分而治之的思想，让快速排序在实际中表现得非常高效。