快速排序算法分析

1. 主要思路

2. 过程演示

3. 代码演示

public class QuickSort {

    /**
     快速排序
        在 Java中, 快速排序被用作基本数据类型的排序  (当然, 不只快速排序一种)
        快速排序是实践中的一种快速的排序算法, 在 C++或对 Java基本类型的排序证特别有用.
        它的平均运行时间是 O(N logN), 该算法之所以特别快, 主要是由于非常精炼和高度优化的内部循环.
        它的最坏情形性能为 O(N^2), 但经过稍许努力可是这种情形极难出现.
        通过将快速排序和堆排序结合, 由于堆排序的 O(N logN)最坏情形运行时间, 我们可以对几乎所有的输入都能达到快速排序的快速运行时间

     */
    public static <AnyType extends Comparable<? super AnyType>> void quickSort(AnyType[] a) {
        quickSort(a, 0, a.length - 1);
    }

    /**
     * 快速排序主例程
     * 
     * @param a 原始数组
     * @param left 起始索引
     * @param right 结束索引
     * @param <AnyType> 实现了 Comparable接口的类或其子类
     */
    private static <AnyType extends Comparable<? super AnyType>> void quickSort(AnyType[] a, int left, int right) {

        // 定义数组大小边界, 小于这个值时使用插入排序
        int CUTOFF = 10;

        // 数组元素较少的时候, 使用插入排序来获取更快的速度; 元素较多时, 使用快排
        if (left + CUTOFF <= right) {

            // 三数中值分割法产生枢纽元
            AnyType pivot = median3(a, left, right);

            // i: 比枢纽元小的元素起始索引; j: 大元素的起始索引
            int i = left, j = right - 1;

            for ( ; ; ) {
                // 小元素指针不断向右推进, 直到找到比枢纽元大的元素
                while (a[++i].compareTo(pivot) < 0) {

                }
                // 大元素指针向左推进, 遇到比枢纽元小的元素终止
                while (a[--j].compareTo(pivot) > 0) {

                }
                // 两个索引未交叉时, 代表大小序列还未分割完成, 交换位置后继续分割
                // 交叉时代表分割完成
                if (i < j)
                    swap(a, i, j);
                else
                    break;
            }

            // 分割完成后, 将枢纽元和小元素索引终止处的元素位置互换
            // 此时, 枢纽元左侧都为小元素, 右侧都为大元素 (相对于枢纽元而言)
            swap(a, i, right - 1);

            // 对分割后的子序列重复上面操作
            quickSort(a, left, i - 1);
            quickSort(a, i + 1, right);

        } else {
            insertionSort(a, left, right);
        }

    }

    /**
     * 对数组的指定部分使用插入排序
     * @param a 原始数组
     * @param left 起始索引
     * @param right 结束索引
     * @param <AnyType> 实现了 Comparable接口的类型或其子类
     */
    private static <AnyType extends Comparable<? super AnyType>> void insertionSort(AnyType[] a, int left, int right) {

        if (right - left == 0 || left < 0 || right > a.length - 1) {
            return;
        }

        AnyType tmp;
        int j;
        for (int i = left + 1; i <= right; i++) {
            tmp = a[i];
            for (j = i; j > left && tmp.compareTo(a[j - 1]) < 0; j--) {
                a[j] = a[j - 1];
            }
            a[j] = tmp;
        }
    }

    /**
     三数中值分割法
        使用左端, 右端和中心位置上的三个元素的中值作为枢纽元
     */
    private static <AnyType extends Comparable<? super AnyType>> AnyType median3(AnyType[] a, int left, int right) {

        int center = (right - left) / 2;

        // 对左中右三个位置的元素位置进行调整
        // 最小的元素被放在最左端, 最大的元素放在最右端, 中间的元素放在中间位置, 中间元素要作为枢纽元
        if (a[center].compareTo(a[left]) < 0) {
            swap(a, left, center);
        }
        if (a[right].compareTo(a[left]) < 0) {
            swap(a, left, right);
        }
        if (a[right].compareTo(a[center]) < 0) {
            swap(a, center, right);
        }

        // 将枢纽元和右端倒数第二个元素交换位置, 使枢纽元离开数组, 便于元素比较
        swap(a, center, right - 1);

        // 将枢纽元返回
        return a[right - 1];
    }

    /**
     * 交换数组中两个元素的位置
     */
    private static <AnyType extends Comparable<? super AnyType>> void swap(AnyType[] arr, int i, int j) {
        if (arr == null || arr.length <= 1 || i == j) {
            return;
        }

        AnyType tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

4. 复杂度分析