java常见排序算法——快速排序

首先说明一下，此案例中的排序是基于数组升序排列。

原理：快速排序是一种排序执行效率很高的排序算法，是由冒泡排序改进而得到的，它利用分治法来对待排序序列进行分治排序，它的思想主要是通过一趟排序将待排记录分隔成独立的两部分，其中的一部分比基准值小，后面一部分比基准值大，然后再对这前后的两部分分别采用这种方式进行排序，通过递归的运算最终达到整个序列有序。

思路：

1. 在待排序的数组中任取一个元素(通常取第一个记录)作为基准（基准的选取可能会影响到排序的效率），称为基准记录；
2. 定义两个索引 low和 high分别表示“首索引” 和 “尾索引”，key 表示“基准值”；
3. 首先，尾索引向前扫描，直到找到比基准值小的记录并且此时low小于high；
4. 然后，首索引向后扫描，直到找到比基准值大于的记录并且此时low小于high；
5. 根据4、5步骤记录的low和high索引值，交换左右元素；
6. 若在扫描过程中首索引等于尾索引(low = high),则一趟排序结束；将基准值(key)替换首索引所对应的值；
7. 再进行下一趟排序时，待排序列被分成两个区:[startIndex,low-1],[high+1,endIndex]
8. 对每一个分区重复步骤1~7，直到所有分区中的记录都有序，排序成功。

下面用代码实现一下：

	public static void main(String[] args) {
        // 定义数组长度
        int arrLength = 10;
        // 声明一个数组
        int[] arr = new int[arrLength];
        // 初始化数组
        Random rand = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = rand.nextInt(50);
        }
        System.out.println("排序前数组: " + Arrays.toString(arr));

        // 使用快速排序
        quickSort(arr, 0, arr.length - 1);

        System.out.println("排序后数组: " + Arrays.toString(arr));
    }

    /**
     * 快速排序,使用递归的思想
     * 
     * @param arr 需要排序的数组
     * @param startIndex 开始索引
     * @param endIndex 结束索引
     */
    public static void quickSort(int[] arr, int startIndex, int endIndex) {
        // 如果开始索引大于等于结束索引则退出递归
        if (startIndex >= endIndex)
            return;

        // 选择一个基准,可以任意选择,这里直接选择第一个元素作为索引
        int key = arr[startIndex];

        int low = startIndex;// 记录开始的位置
        int high = endIndex;// 记录结束的位置

        while (low < high) { // 左边索引小于右边索引才进行循环
            // 从右边查找,找到比基准小的元素,退出循环
            while (arr[high] >= key && high > low) {
                --high;
            }

            // 从左边查找,找打比基准大的元素,退出循环
            while (arr[low] <= key && high > low) {
                ++low;
            }

            // 交换元素
            if (low < high) {
                int temp = arr[low];
                arr[low] = arr[high];
                arr[high] = temp;
            }
        }

        // 两边元素已经分离好了,将基准元素放到中间(基准归位)
        arr[startIndex] = arr[low];
        arr[low] = key;

        // 使用递归,将分隔好的左边和右边子数组继续排序
        // 左
        quickSort(arr, startIndex, low - 1);// 跳过老的基准元素
        // 右
        quickSort(arr, high + 1, endIndex);
    }

运行结果：

排序前数组: [49, 20, 31, 25, 39, 25, 5, 44, 20, 14]
排序后数组: [5, 14, 20, 20, 25, 25, 31, 39, 44, 49]

快速排序最好时间复杂度：O(NlogN)，最坏时间复杂度：O(N²)，平均时间复杂度：O(NlogN)。