算法——快速排序

算法思想

• 如果要排序数组中下标从 p 到 r 之间的一组数据，我们选择 p 到 r 之间的任意一个数据作为 pivot（分区点）。我们遍历 p 到 r 之间的数据，将小于 pivot 的放到左边，将大于 pivot 的放到右边，将 pivot 放到中间。经过这一步骤之后，数组 p 到 r 之间的数据就被分成了三个部分，前面 p 到 q-1 之间都是小于 pivot 的，中间是 pivot，后面的 q+1 到 r 之间是大于 pivot 的。
  快排是一种原地、不稳定的排序算法。
  单边循环快排（lomuto洛穆托分区方案）
  1、选择最右元素作为基准点元素。
  2、从前面开始寻找，j指针负责找到小于基准点的元素，一旦找到则与i进行交换。
  3、i指针维护小于基准点的元素，也就是i的左边都小于基准点，也是每次交换的目标索引。
  4、最后基准点与i进行交换，i即为分区位置。（完成左边都比基准点小、右边都比基准点大）

package com.jie.quick;

import java.util.Arrays;

/**
 * @Author 小杰
 * @Date 2022/5/4 21:19
 * @Version 1.0
 * 快速排序
 * 单边循环。(递归)
 */
public class QuickSort {
    public static void main(String[] args) {
        int[] a = {5, 3, 7, 2, 9, 8, 1, 4};
        quick(a,0,a.length-1);
    }

    /**
     * 递归
     *
     * @param a
     * @param l
     * @param h
     */
    public static void quick(int[] a, int l, int h) {
        //递归结束条件
        if (l>=h){
            return ;
        }
        //p 索引值。
        int p = partition(a, l, h);
        //向左递归(左边分区范围确定)
        quick(a, l, p - 1);
        //向右递归
        quick(a, p + 1, h);
    }

    public static int partition(int[] a, int l, int h) {

        //定义基准点元素。
        int pv = a[h];
        int i = l;
        for (int j = l; j < h; j++) {
            if (a[j] < pv) {
                if (i!=j){
                    exchange(a, i, j);
                }
                i++;
            }
        }
        //交换i与基准点的值。
        if (i!=h){
            exchange(a, i, h);
        }
        System.out.println(Arrays.toString(a) + "i=" + i);
        //返回值代表基准点元素所代表的索引，它可以来确定下一次总分区的边界。
        return i;
    }

    /**
     * 交换数组两个位置元素。
     *
     * @param a
     * @param i
     * @param j
     */
    public static void exchange(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

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

1、选择最左元素为基准点元素。
2、j指针负责从右向左找比基准点小的元素，如果找到就暂停；i指针负责从左向右找比基准点大的元素，一旦找到，i和j的值交换，直至i、j相交。
3、最后基准点与i交换（此时i、j相等），i即为分区位置。

package com.jie.quick;

import java.util.Arrays;

/**
 * @Author 小杰
 * @Date 2022/5/5 9:17
 * @Version 1.0
 * 双边
 */
public class QuickSort2 {
    public static void main(String[] args) {
        int[] a = {5, 3, 7, 2, 9, 8, 1, 4};
        quick(a, 0, a.length - 1);
    }

    /**
     * 递归
     *
     * @param a
     * @param l
     * @param h
     */
    public static void quick(int[] a, int l, int h) {
        //递归结束条件
        if (l >= h) {
            return;
        }
        //p 索引值。
        int p = partition(a, l, h);
        //向左递归(左边分区范围确定)
        quick(a, l, p - 1);
        //向右递归
        quick(a, p + 1, h);
    }

    /**
     * 双边
     *
     * @return
     */
    public static int partition(int[] a, int l, int h) {
        //1、选择最左元素为基准点元素。
        int pv = a[l];
        int i = l;
        int j = h;
        //2、j指针负责从右向左找比基准点小的元素，如果找到就暂停；i指针负责从左向右找比基准点大的元素，
        while (i < j) {
            //j从右找小的
            while (i < j && a[j] > pv) {
                j--;
            }
            //i从左找大的
            while (i < j && a[i] <= pv) {
                i++;
            }
            // 一旦找到，i和j的值交换，直至i、j相交。
            exchange(a, i, j);
        }
        //3、最后基准点与i交换（此时i、j相等），i即为分区位置。
        exchange(a, l, j);
        System.out.println(Arrays.toString(a) + "j=" + j);
        return j;
    }

    /**
     * 交换数组两个位置元素。
     *
     * @param a
     * @param i
     * @param j
     */
    public static void exchange(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

注意：
1、基准点在左边，必须先找j，再找i。
2、循环条件一个不能少，可以用反证法验证。

算法分析

平均时间复杂度O（nlogn），最坏时间复杂度O（n*n）,辅助空间O（logn）<每次都要分给一个额外空间，而总共有logn次>
每次分成两段，那么分的次数就是logn了，每一次处理需要n次计算，那么时间复杂度就是nlogn了！
根据平均情况来说是O(nlogn),因为在数据分布等概率的情况下对于单个数据来说在logn次移动后就会被放到正确的位置上了。
最坏是O(n^2).这种情况就是数组刚好的倒序，然后每次去中间元的时候都是取最大或者最小。

稳定性：不稳定。

• 祝你：吉时吉日喜如风，丰年丰月如风增，争富争财争长寿，寿山寿海寿长生，生富生才生贵子，子孝孙贤代代荣，荣华富贵年年有，有钱有势有前程！
• 祝你：吃不愁穿不愁，不住平方住高楼，天天潇洒，夜夜温柔，买卖如同长江水，生活如同井上花，大财小财天天进，一顺百顺发发发！
• 点点关注不迷路，感谢老铁的关注。