快速排序

快速排序

是对冒泡排序的一种改进，采用的是分治策略(一般与递归结合使用)，时间复杂度( O(nlogn) ) , 最坏情况( O(n²) )

快速排序实现基本思路 : 

1 . 先通过第一趟排序，将原数组划分为两部分，其中一部分的所有数据都小于另一部分的所有数据。原数组被划分为两部分。

2 . 通过递归的处理，再对原数据分割的两部分分别划分为两部分，同样使得其中一部分的所有数据都小于另一部分的所有数据。

3 . 就这样不断划分直到最后，数组被划分为由多个一个元素(或多个元素)组成的单元，这样数组就有序了。

说明 : 划分数组的时候会选择一个元素作为基准元素。一般基准元素选择为数组的第一个元素.

Java代码实现(可运行)

/**
 * 快速排序
 */
public class QuickSort {

    /**
     * 测试
     */
    public static void main(String[] args) {
        int[] array = {3, 1, 4, 2, 7, 5, 9, 6, 0, 8};
        quickSort(array);
        for (int i : array) {
            System.out.print(array[i] + "  ");
        }

    }

    /**
     * 算法实现
     */
    private static void recQuickSort(int[] array, int left, int right) {
        if (right > left) {
            int partition = partitionIt(array, left, right);
            recQuickSort(array, left, partition - 1);
            recQuickSort(array, partition + 1, right);

        }
    }

    private static int partitionIt(int[] array, int left, int right) {
        int i = left;
        int j = right + 1;
        int pivot = array[left]; // 基准元素(头元素)
        while (true) {
            while (i < right && array[++i] < pivot) {
                System.out.print("");
            }
            while (j > 0 && array[--j] > pivot) {
                System.out.print("");
            }
            if (i >= j) {
                break;
            } else {
                swap(array, i, j);
            }
        }
        swap(array, left, j); // 基准元素交换
        return j;
    }

    public static void quickSort(int[] array) {
        recQuickSort(array, 0, array.length - 1);
    }

    /**
     * 数组中两个元素交换
     *
     * @param array 排序数组
     * @param i     交换下标
     * @param j     交换下标
     */
    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

优化分析

快速排序具有最好平均性能O(nlogn)，但也有最坏性能和插入排序相同，也是O(n^2)。比如一个序列5,4,3,2,1，要排为1,2,3,4,5。按照快速排序方法，每次只会有一个数据进入正确顺序，不能把数据分成大小相当的两份，很明显，排序的过程就
成了一个歪脖子树，树的深度为n，那时间复杂度就成了O(n^2)。

针对最坏性能的时候，其实我们也是可以有一些优化的办法：理想状态下，应该选择被排序数组的中值数据作为基准，也就可以让一半的数大于基准数，一半的数小于基准数，这样会使得数组被划分为两个大小相等的子数组，对快速排序来说，拥有两个大小相等的子数组是最优的情况。 

三项取中划分
为了找到一个数组中的中值数据，一般是取数组中第一个、中间的、最后一个，选择这三个数中位于中间的数。