快速排序算法

快速排序

1. 每一轮排序选择一个基准点（pivot）进行分区
   1 让小于基准点的元素的进入一个分区，大于基准点的元素的进入另一个分区
   2. 当分区完成时，基准点元素的位置就是其最终位置
2. 在子分区内重复以上过程，直至子分区元素个数少于等于 1，这体现的是分而治之的思想 （[divide-and-conquer]
3. 从以上描述可以看出，一个关键在于分区算法，常见的有洛穆托分区方案、双边循环分区方案、霍尔分区方案

单边循环快排（lomuto 洛穆托分区方案）

1. 选择最右元素作为基准点元素

2. j 指针负责找到比基准点小的元素，一旦找到则与 i 进行交换

3. i 指针维护小于基准点元素的边界，也是每次交换的目标索引

4. 最后基准点与 i 交换，i 即为分区位置

public static void main(String[] args) {
        //快速排序，单边循环
        int[] array = {5, 7, 2, 3, 9, 1, 8, 6, 4};
        quick(array, 0, array.length - 1);
    }
    private static void quick(int[] array, int l, int h){
        if (l>=h){
            return;
        }
        int p = partition(array, l, h);
        quick(array,l,p-1);
        quick(array,p+1,h);
    }
    private static int partition(int[] array, int l, int h) {
        int pv = array[h]; //基准点元素
        int i = l;
        for (int j = l; j < h; j++) {
            if (array[j] < pv) {
                if (i != j) {
                    swap(array, i, j);
                }
                i++;
            }
        }
        System.out.println(Arrays.toString(array));
        if (i != h) {
            swap(array, h, i);
        }
        return i; //返回值代表基准点元素所在的索引位置
    }
     private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

双边循环（不完全等价于 hoare 霍尔分区方案）

1. 选择最左元素作为基准点元素
2. j 指针负责从右向左找比基准点小的元素，i 指针负责从左向右找比基准点大的元素，一旦找到二者交换，直至 i，j 相交
3. 最后基准点与 i（此时 i 与 j 相等）交换，i 即为分区位置

public static void main(String[] args) {
        //快速排序，双边循环
        int[] array = {5, 7, 2, 3, 9, 1, 8, 6, 4};
        quick(array, 0, array.length - 1);
    }
    private static void quick(int[] array, int l, int h){
        if (l>=h){
            return;
        }
        int p = partition(array, l, h);
        quick(array,l,p-1);
        quick(array,p+1,h);
    }
    private static int partition(int[] array, int l, int h) {
        int pv = array[l];
        int i = l;
        int j = h;
        while (i < j) {
            // j 从右找小的
            while (i < j && array[j] > pv) {
                j--;
            }
            // i 从左找大的
            while (i < j && array[i] <= pv) {
                i++;
            }
            swap(array, i, j);
        }
        swap(array, l, j);
        System.out.println(Arrays.toString(array) );
        return j;
    }
     private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

快排特点

4. 平均时间复杂度是 $O(nlo{g}_{2}n)$，最坏时间复杂度 $O(n^2)$

5. 数据量较大时，优势非常明显

6. 属于不稳定排序

**霍尔的移动次数平均来讲比洛穆托少3倍