排序算法 - 快速排序

排序算法 - 快速排序

   概要

   快速排序（Quicksort）是对冒泡排序算法的一种改进。快速排序是一种基于分而治之的排序算法。

   它的基本思想是: 选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分；其中一部分的所有数据都比另外一部分的所有数据都要小。然后，再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

   基准元素的选择，以及元素的交换，都是快速排序的核心问题。    

   一、基准元素的选择

   最简单的方式是选择第1个元素。但是针对特殊情况比如原本逆序的数列：{8,7,6,5,4,3,2,1}，期望排列成顺序数列，整个数列并没有被分成两半。如何避免这种情况？

   解决办法：随机选择一个基准元素，并且让基准元素和数列首元素交换位置。

   二、元素的交换

   选定了基准元素以后，我们要做的就是把其他元素中小于基准元素的都交换到基准元素一边，大于基准元素的都交换到基准元素的另一边。具体实现有两种方法。

   1. 双边循环法

   以[4,7,5,2,6,1,3] 为例，下面讲解具体实现过程：

   1）选定基准元素pivot，并且设置两个指针left（下图中的i）和right （下图中的j），指向数列的最左和最右两个元素。如下图：

 

 

 

   2）接下来进行第1次循环，从right指针开始，让指针所指向的元素和基准元素做比较，如果大于等于pivot，则指针向左移动。如果小于pivot，则right指针停止移动，切换到left指针。

   3）轮到left指针，让指针所指向的元素和基准元素做比较，如果小于等于pivot，则指针向右移动。如果大于pivot，则left指针停止移动。 让left和right指针所指向的元素进行交换。  

   4）接下来进入第2次循环，重新切换到right指针，向左移动。按照这个思路继续往下，

   最后，等到left指针和right指针重合的时候，将left指针所指向的元素和基准元素所在位置的元素进行交换。返回left指针所在的位置，这个就是基准元素的位置，根据基准元素，分成两部分递归排序。

   如下图：

   下面是用java来实现的参考代码：

public class QuickSort {
    public static void quickSort(int[] arr, int startIndex, int endIndex) {
        // 递归结束条件：startIndex大等于endIndex的时候
        if (startIndex >= endIndex) {
            return;
        }
        // 得到基准元素位置
        int pivotIndex = partition(arr, startIndex, endIndex);
        // 根据基准元素，分成两部分递归排序
        quickSort(arr, startIndex, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, endIndex);
    }

    /**
     * 分治（双边循环法）
     *
     * @param arr        待交换的数组
     * @param startIndex 起始下标
     * @param endIndex   结束下标
     */
    private static int partition(int[] arr, int startIndex, int endIndex) {
        // 取第一个位置的元素作为基准元素（也可以选择随机位置）
        int pivot = arr[startIndex];
        int left = startIndex;
        int right = endIndex;

        while (left != right) {
            //控制right指针比较并左移
            while (left < right && arr[right] >= pivot) {
                right--;
            }
            //控制left指针比较并右移
            while (left < right && arr[left] <= pivot) {
                left++;
            }
            //交换left和right指向的元素
            if (left < right) {
                int p = arr[left];
                arr[left] = arr[right];
                arr[right] = p;
            }
        }

        //pivot和指针重合点交换
        arr[startIndex] = arr[left];
        arr[left] = pivot;

        return left;
    }

    public static void main(String[] args) {
        int[] arr = new int[]{4, 7, 3, 5, 6, 2, 8, 1};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
}

    2. 单边循环法

    双边循环法从数组两边交替遍历元素，虽然更加直观，但是代码实现相对繁琐，而单边循环法则简单得多，只从数组的一边对元素进行遍历和交换。

    mark指针代表小于基准元素的区域边界。

    具体实现过程：

    1）从基准元素的下一个位置开始遍历数组。

    2）如果遍历到的元素值大于等于基准元素时，就继续往后遍历

    3）如果遍历到的元素小于基准元素值时，则需要做两件事：

• 将mark指针右移1位，因为小于pivot的区域边界增大。
• 让最新遍历到的元素和mark指针所在位置的元素交换位置，因为最新遍历的元素归属于小于pivot的区域。

    最后，将pivot元素交换到mark指针所在位置，返回mark指针所在的位置，这个就是基准元素的位置，根据基准元素，分成两部分递归排序。这一轮宣告结束。

    下面是用java实现的参考代码：

 

public class QuickSort {
    public static void quickSort(int[] arr, int startIndex, int endIndex) {
        // 递归结束条件：startIndex大等于endIndex的时候
        if (startIndex >= endIndex) {
            return;
        }
        // 得到基准元素位置
        int pivotIndex = partition(arr, startIndex, endIndex);
        // 根据基准元素，分成两部分递归排序
        quickSort(arr, startIndex, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, endIndex);
    }

    /**
     * 分治（单边循环法）
     *
     * @param arr        待交换的数组
     * @param startIndex 起始下标
     * @param endIndex   结束下标
     */
    private static int partition(int[] arr, int startIndex, int endIndex) {
        // 取第一个位置的元素作为基准元素（也可以选择随机位置）
        int pivot = arr[startIndex];

        //小于基准元素的区域边界
        int mark = startIndex;

        //从基准元素的下一个位置开始遍历数组
        for (int i = startIndex + 1; i <= endIndex; i++) {
            if (arr[i] < pivot) {
                mark++;
                int p = arr[mark];
                arr[mark] = arr[i];
                arr[i] = p;
            }
        }

        arr[startIndex] = arr[mark];
        arr[mark] = pivot;
        return mark;
    }

    public static void main(String[] args) {
        int[] arr = new int[]{4, 7, 3, 5, 6, 2, 8, 1};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
}

 

   三、总结

   1. 快速排序是从冒泡排序演变而来的，同冒泡排序一样，快速排序也属于交换排序，通过元素之间的比较和交换位置来达到排序的目的。

   2. 是一种不稳定排序，平均时间复杂度是O(nlogn)，最坏时间复杂度为O(n²)，空间复杂度为O(logn)

   3. 快速排序是很重要的算法，与傅里叶变换等算法并成为二十世纪十大算法

   4. 核心问题：基准元素的选择以及元素的交换

   四、快速排序与冒泡排序的区别

   1. 排序方式

   冒泡排序在每一轮只把1个元素冒泡到数列的一端。

   而快速排序则在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成两个部分。

   2. 使用场景

   快速排序适合处理大规模数据，尤其是随机分布的数据。而冒泡排序适合小规模数据。总体来说，快速排序在效率和性能上通常优于冒泡排序，尤其在处理大数据时。

   参考链接：https://algo.itcharge.cn/