【十大排序算法系列】快速排序

写在前面

• 上一篇更新了这个系列的排序算法（【十大排序算法系列】冒泡排序）。分析了冒泡的逻辑和优化点，下面来写下快速排序（为什么跳这么快？因为比较走心hhhh）
  照例给出系列内所有算法的对比。。
• 常见的十大排序算法有：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序等。

常见的十大排序算法，时间复杂度和空间复杂度如下图：

---

快速排序

快速排序（QuickSort），为什么要叫快速排序呢，因为它真的很快，是对冒泡排序的一些改进，在1960年（管它多少年）被人提出。（2021.01.9 修正：由C. A. R. Hoare在1960年提出。（百度百科））

介绍

1. 快速排序是指通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序。整个排序过程可以递归进行，以此达到整个数据变成有序序列。
2. 快速排序的时间复杂度为 O(nlogn)

步骤

1. 定义一个初始基准元素pivot，来把序列划分成两部分，其中左边部分全部比基准元素小，右边部分全部比基准元素大。这个基准元素从序列里找，一般找左边第一个元素。
2. 定义两个指针，分别指向序列的头和尾，然后开始向中间移动。其中左指针查找比基准元素大的值，放到队列的右边；右指针查找比基准元素小的值，放到队列的左边。如此一来，一趟遍历过后，可以确定到基准元素的位置
3. 基准元素确定后，就相当于一个挡板，把序列分成两段，然后这时，再对这两段分别进行一次快速排序（重复1、2步）。直到左指针大于等于右指针。

有点抽象，可能表达不够好，放一个b站看到的视频链接（动画介绍冒泡和快速排序）

Java代码实现快速排序

import java.util.Arrays;

/**
 * 快速排序.
 *
 * @author linzp
 * @version 1.0.0
 * @date 2021/1/2 22:37
 */
public class QuickSort {

    public static void main(String[] args) {

        //待排序数组
        int[] array = new int[]{11,4, 3, 8, 6, 8, 2, 3, 1, 10, 9};
        //定义左指针
        int left = 0;
        //定义右指针
        int right = array.length - 1;
        //开始执行快速排序逻辑
        System.out.println("--------排序前-----------");
        System.out.println(Arrays.toString(array));
        quickSort2(array, left, right);
        System.out.println("--------排序后-----------");
        System.out.println(Arrays.toString(array));
    }

    /**
     * 快速排序算法.
     * 逻辑.
     * 1.得到基准元素的位置
     * 2.比基准元素小的值放在左边，比基准元素大的值放在右边
     * 3.对得到的序列再次进行快速排序，直到左指针大于等于右指针
     * @param array      待排序数组
     * @param startIndex 开始下标
     * @param endIndex   结束下标
     */
    public static void quickSort2(int[] array, int startIndex, int endIndex) {

        //判断排序是否结束
        if (startIndex >= endIndex) {
            return;
        }

        //记录当前轴所在的元素值.
        int pivot = array[startIndex];
        //定义左右指针，左指针用于寻找比轴大的元素，右指针用于寻找比小的元素
        int left = startIndex;
        int right = endIndex;

        //1、大循环，把比轴大的元素放在右边，比轴小的元素放在左边
        while (left != right) {
            //这里轴选的是最左的元素，所以先移动右指针！
            //2、小循环，移动右指针，直到寻找到比轴小的值
            while (array[right] >= pivot && left < right) {
                right--;
            }
            //3、小循环，移动左指针，直到寻找到比轴大的值
            while (array[left] <= pivot && left < right) {
                left++;
            }
            //4、左右指针均移动完毕，均寻找到了比轴大和比轴小的元素，
            //判断此时左右指针是否正常，然后交换左右指针所指向的元素值
            if (left < right) {
                int temp = array[left];
                array[left] = array[right];
                array[right] = temp;
            }
            //交换完后，继续判断左右指针，重复篇2、3、4步
        }

        //到这里证明左右指针已经重合了，所指向的元素位置应该是轴的位置，交换轴与该位置的值，把轴放到这里来
        //把当前左指针（右指针）指向的值放到轴的位置
        array[startIndex] = array[left];
        //把轴的值放到左指针（右指针）指向的位置
        array[left] = pivot;

        //这里轴已经确定了，继续对被轴分隔的左边，和右边的序列分别进行快排，直到序列的长度为1（分治法）
        //左边序列快排
        quickSort2(array, startIndex, left - 1);
        //右边序列快排
        quickSort2(array, left + 1, endIndex);
    }
}

PS：每行代码都写了注释进行阐述，先到此为止

其实也可以使用单指针来实现这个逻辑，简化流程。递归也不是必须的，可以用栈的后进先出特点，来代替递归，把方法入参存起来，记录方法调用的先后顺序就可以在后面进行还原了。