快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是：**通过一趟排序将要排序的数据分割成独立的两部分，其中一

部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序
过程可以递归进行，以此达到整个数据变成有序序列。**

排序原理

（1）首先设定一个分界值，通过该分界值将数组分成左右两部分；
（2）将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于
或等于分界值，而右边部分中各元素都大于或等于分界值；
（3）然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两
部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
（4）重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当
左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。

API的设计

切分原理

把一个数组切分成两个子数组的基本思想：
1.找一个基准值，用两个指针分别指向数组的头部和尾部；
2.先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置；
3.再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置；
4.交换当前左边指针位置和右边指针位置的元素；
5.重复2,3,4步骤，直到左边指针的值大于右边指针的值停止。

代码实现

import org.junit.Test;

import java.util.Arrays;

/**
 * 快速排序
 */
public class Quick {
    /**
     * 对数组内的元素进行排序
     *
     * @param a
     */
    public static void sort (Comparable[] a) {
        int lo = 0;
        int hi = a.length - 1;
        sort(a, lo, hi);
    }

    /**
     * 对数组a中从索引lo到索引hi之间的元素进行排序
     */
    private static void sort (Comparable[] a, int lo, int hi) {
        //限定递归条件
        if (lo >= hi) {
            return;
        }

        //对a数组中，从lo到hi的元素进行切分，寻找切分界限的索引
        int partition = partition(a, lo, hi);
        //对左边分组的元素进行排序
        sort(a, lo, partition - 1);
        //对右边分组的元素进行排序
        sort(a, partition + 1, hi);
    }

    /**
     * 对数组a中从lo索引到hi索引之间的元素进行分组
     * 返回分组界限对应的索引
     */
    private static int partition (Comparable[] a, int lo, int hi) {
        //定义一个基准值
        Comparable key = a[lo];

        //定义一个左指针，初始化指向最左边的元素
        int left = lo;

        //定义一个右指针，初始化指向右边的元素的下一个
        int right = hi + 1;


        while (true) {
            //从头部寻找比基准值大  所在的索引
            while (left < hi) {
                //找到比基准值大的值，结束循环
                if (less(key, a[++left])) {
                    break;
                }
            }

            //从尾部开始寻找一个值 比基准值小 ，找出他的索引

            while (right > lo) {
                //找到比基准值小的值，结束循环
                if (less(a[--right], key)) {
                    break;
                }
            }
            if (left >= right) {
                break;
            } else {
                //交换元素
                exch(a, left, right);
            }


        }

        //将right索引处的元素和最左边的lo处元素交换

        exch(a, lo, right);
        return right;
    }


    /**
     * 比较v元素是否小于w元素
     */
    private static boolean less (Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    /**
     * 交换a数组中，索引i和索引j处的值
     */
    private static void exch (Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    @Test
    public void test () {
        Integer[] a = {9, 8, 7, 5, 4, 3, 2, 1};
        sort(a);
        System.out.println(Arrays.toString(a));
    }


}

快速排序时间复杂度分析

快速排序的一次切分从两头开始交替搜索，直到left和right重合，因此，一次切分算法的时间复杂度为O(n),但整个
快速排序的时间复杂度和切分的次数相关。
最优情况：每一次切分选择的基准数字刚好将当前序列等分。

如果我们把数组的切分看做是一个树，那么上图就是它的最优情况的图示，共切分了logn次，所以，最优情况下快
速排序的时间复杂度为O(nlogn);
最坏情况：每一次切分选择的基准数字是当前序列中最大数或者最小数，这使得每次切分都会有一个子组，那么总
共就得切分n次，所以，最坏情况下，快速排序的时间复杂度为O(n^2);

平均情况：每一次切分选择的基准数字不是最大值和最小值，也不是中值，这种情况我们也可以用数学归纳法证
明，快速排序的时间复杂度为O(nlogn),由于数学归纳法有很多数学相关的知识，容易使我们混乱，所以这里就不对
平均情况的时间复杂度做证明了。