常用排序算法总结

最新推荐文章于 2021-10-22 19:10:39 发布

骑山猪上学

最新推荐文章于 2021-10-22 19:10:39 发布

阅读量160

点赞数

文章标签：排序算法 Java

转载链接

排序算法大致可分为两种：

比较排序，时间复杂度为 $O(nlogn)$ ~ $O(n ^ 2)$ ，主要有：
- 冒泡排序
- 选择排序
- 插入排序
- 归并排序
- 堆排序
- 快速排序
非比较排序，时间复杂度可以达到O(n)，主要有：
- 计数排序
- 基数排序
- 桶排序

这里我们要探讨的是较常见的比较排序，下表给出常见的比较排序性能：

$排序方法$ $排序方法$	$平均情况$ $平均情况$	$最好情况$ $最好情况$	$最坏情况$ $最坏情况$	$辅助空间$ $辅助空间$	$稳定性$ $稳定性$
$冒泡排序$ $冒泡排序$	$O (n 2)$ $O(n^2)$	$O (n)$ $O(n)$	$O (n 2)$ $O(n^2)$	$O (1)$ $O(1)$	$稳$ $稳$
$简单选择排序$ $简单选择排序$	$O (n 2)$ $O(n^2)$	$O (n 2)$ $O(n^2)$	$O (n 2)$ $O(n^2)$	$O (1)$ $O(1)$	$不稳$ $不稳$
$直接插入排序$ $直接插入排序$	$O (n 2)$ $O(n^2)$	$O (n)$ $O(n)$	$O (n 2)$ $O(n^2)$	$O (1)$ $O(1)$	$稳$ $稳$
$希尔排序$ $希尔排序$	$O (n l o g n)$ $O(nlogn)$ 至 $O (n 2)$ $O(n^2)$	$O (n 1 .3)$ $O(n^1.3)$	$O (n 2)$ $O(n^2)$	$O (1)$ $O(1)$	$不稳$ $不稳$
$堆排序$ $堆排序$	$O (n l o g n)$ $O(nlogn)$	$O (n l o g n)$ $O(nlogn)$	$O (n l o g n)$ $O(nlogn)$	$O (1)$ $O(1)$	$不稳$ $不稳$
$归并排序$ $归并排序$	$O (n l o g n)$ $O(nlogn)$	$O (n l o g n)$ $O(nlogn)$	$O (n l o g n)$ $O(nlogn)$	$O (n)$ $O(n)$	$稳$ $稳$
$快速排序$ $快速排序$	$O (n l o g n)$ $O(nlogn)$	$O (n l o g n)$ $O(nlogn)$	$O (n 2)$ $O(n^2)$	$O (l o g n)$ $O(logn)$ 至 $O (n)$ $O(n)$	$不稳$ $不稳$

有一点我们很容易忽略的是排序算法的稳定性（腾讯校招2016笔试题曾考过）。

排序算法稳定性的简单形式化定义为，如果 $A_i$ = $A_j$ ，排序前 $A_i$ 在 $A_j$ 之前，排序后 $A_i$ 还在 $A_j$ 之前，则称这种排序算法是稳定的，通俗地讲就是保证排序前后两个相等的数的相对顺序不变。

对于不稳定的排序算法，只要举出一个实例，即可说明它的不稳定性；而对于稳定的排序算法，必须对算法进行分析从而得到稳定的特性。需要注意的是，排序算法是否为稳定的是由具体算法决定的，不稳定的算法在某种条件下可以变为稳定的算法，而稳定的算法在某种条件下也可以变为不稳定的算法。

例如，对于冒泡排序，原本是稳定的排序算法，如果将记录交换的条件改成A[i] >= A[i + 1]，则两个相等的记录就会交换位置，从而变成不稳定的排序算法。

其次，说一下排序算法稳定性的好处。排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，前一个键排序的结果可以为后一个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位排序后元素的顺序在高位也相同时是不会改变的。

冒泡排序（Bubble Sort）

冒泡排序是一种极其简单的排序算法，也是我所学的第一个排序算法。它重复地走访过要排序的元素，依次比较相邻两个元素，如果他们的顺序错误就把他们调换过来，直到没有元素再需要交换，排序完成。这个算法的名字由来是因为越小（或越大）的元素会经由交换慢慢浮到数列的顶端。

冒泡排序算法的运作如下：

比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

由于它的简洁，冒泡排序通常被用来对于程序设计入门的学生介绍算法的概念。
冒泡排序的代码如下：

import java.util.Arrays;

/**
 * @分类              内部比较排序
 * @数据结构          数组
 * @最差时间复杂度    O(n^2)
 * @最优时间复杂度    如果能在内部循环第一次运行时，使用一个旗标表示有无需要交换的可能，可以把最优时间复杂度降到O(n)
 * @平均时间复杂度    O(n^2)
 * @所需辅助空间      O(1)
 * @稳定性           稳定
 *
 */

public class BubbleSort {
    private void swap(int array[], int i, int j){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public void sort(int array[], int n){
        for (int i = 0; i < n - 1; i++){
            for (int j = 0; j < n - 1 - i; j++){
                if (array[j] > array[j + 1]){       // 如果条件改为array[j] >= array[j + 1]，则变为不稳定的排序算法
                    swap(array, j, j + 1);
                }
            }
        }
    }

    public static void main(String[] args){
        int[] array = {6, 5, 3, 1, 8, 7, 2, 4};
        int length = array.length;
        BubbleSort bubbleSort = new BubbleSort();
        bubbleSort.sort(array, length);
        System.out.println("冒泡排序结果：");
        Arrays.stream(array).forEach(System.out::println);
    }
}

上述代码对序列{ 6, 5, 3, 1, 8, 7, 2, 4 }进行冒泡排序的实现过程如下：
冒泡排序实现
使用冒泡排序为一列数字进行排序的过程如右图所示：冒泡排序过程
尽管冒泡排序是最容易了解和实现的排序算法之一，但它对于少数元素之外的数列排序是很没有效率的。

冒泡排序的改进：鸡尾酒排序

鸡尾酒排序，也叫定向冒泡排序，是冒泡排序的一种改进。此算法与冒泡排序的不同处在于从低到高然后从高到低，而冒泡排序则仅从低到高去比较序列里的每个元素，因此可以得到比冒泡排序稍微好一点的效能。

鸡尾酒排序的代码如下：

import java.util.Arrays;

/**
 * @分类             内部比较排序
 * @数据结构         数组
 * @最差时间复杂度    O(n^2)
 * @最优时间复杂度    如果序列在一开始已经大部分排序过的话，会接近O(n)
 * @平均时间复杂度    O(n^2)
 * @所需辅助空间      O(1)
 * @稳定性           稳定
 *
 */

public class CockTailSort {
    private void swap(int[] array, int front, int back){
        int temp = array[front];
        array[front] = array[back];
        array[back] = temp;
    }

    public void sort(int[] array, int n){
        int left = 0;           // 初始化边界
        int right = n - 1;
        while (left < right) {
            for (int i = left; i < right; i++) {
                if (array[i] > array[i + 1]){
                    swap(array, i, i + 1);
                }
            }
            right--;
            for (int i = right; i > left; i--){
                if (array[i] < array[i - 1]){
                    swap(array, i - 1, i);
                }
            }
            left++;
        }
    }

    public static void main(String[] args){
        int[] array = {6, 5, 3, 1, 8, 7, 2, 4};
        int length = array.length;
        CockTailSort cockTailSort = new CockTailSort();
        cockTailSort.sort(array, length);
        System.out.println("鸡尾酒排序结果：");
        Arrays.stream(array).forEach(System.out::println);
    }
}

使用鸡尾酒排序为一列数字进行排序的过程如右图所示：鸡尾酒排序过程
以序列{2, 3, 4, 5, 1}为例，鸡尾酒排序只需要访问一次序列就可以完成排序，但如果使用冒泡排序则需要四次。但是在乱数序列的状态下，鸡尾酒排序与冒泡排序的效率都很差劲。

选择排序（Selection Sort）

选择排序也是一种简单直观的排序算法。
它的工作原理很容易理解，初始时在序列中找到最小（大）元素，放到序列的起始位置作为已排序序列，然后，再从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

注意选择排序与冒泡排序的区别：
冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；而选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。

选择排序的代码如下：

import java.util.Arrays;

/**
 * @分类              内部比较排序
 * @数据结构          数组
 * @最差时间复杂度    O(n^2)
 * @最优时间复杂度    O(n^2)
 * @平均时间复杂度    O(n^2)
 * @所需辅助空间      O(1)
 * @稳定性           不稳定
 *
 */

public class SelectionSort {
    private void swap(int[] array, int front, int back){
        int temp = array[front];
        array[front] = array[back];
        array[back] = temp;
    }

    public void sort(int[] array, int n){
        for (int i = 0; i < n; i++){            // i为已排序序列的末尾
            int min = i;
            for (int j = 0; j < n; j++){        // 未排序序列
                if (array[j] < array[min]){     // 找出未排序序列中的最小值
                    min = j;
                }
            }
            if (min != i){
                swap(array, min, i);            // 放到已排序序列的末尾，该操作很有可能把稳定性打乱，所以选择排序是不稳定的排序算法
            }
        }
    }

    public static void main(String[] args){
        int[] array = {8, 5, 2, 6, 9, 3, 1, 4, 0, 7};
        int length = array.length;
        SelectionSort selectionSort = new SelectionSort();
        selectionSort.sort(array, length);
        System.out.println("选择排序结果：");
        Arrays.stream(array).forEach(System.out::println);
    }
}

上述代码对序列{ 8, 5, 2, 6, 9, 3, 1, 4, 0, 7 }进行选择排序的实现过程如右图：选择排序过程

使用选择排序为一列数字进行排序的宏观过程：
选择排序宏观过程

选择排序是不稳定的排序算法，不稳定发生在最小元素与A[i]交换的时刻。
比如序列：{ 5, 8, 5, 2, 9 }，一次选择的最小元素是2，然后把2和第一个5进行交换，从而改变了两个元素5的相对次序。

插入排序（Insertion Sort）

插入排序是一种简单直观的排序算法，它的工作原理非常类似于我们抓扑克牌

对于未排序数据（右手抓到的牌），在已排序序列（左手已经排好序的手牌）中从后向前扫描，找到相应位置并插入。
插入排序在实现上，通常采用in-place排序，即只需用到O(1)的额外空间的排序，因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

具体算法描述如下：

从第一个元素开始，该元素可以认为已经被排序
取出下一个元素，在已经排序的元素序列中从后向前扫描
如果该元素（已排序）大于新元素，将该元素移到下一位置
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到该位置后
重复步骤2~5

插入排序的代码如下：

import java.util.Arrays;

/**
 * @分类              内部比较排序
 * @数据结构          数组
 * @最差时间复杂度    最坏的情况为降序排列，此时时间复杂度为O(n^2)
 * @最优时间复杂度    最好的情况为升序排列，此时时间复杂度为O(n)
 * @平均时间复杂度    O(n^2)
 * @所需辅助空间      O(1)
 * @稳定性           稳定
 *
 */

public class InsertionSort {
    public void sort(int[] array, int n){
        for (int i = 0; i < n; i++){                // 类似抓扑克牌排序
            int get = array[i];                     // 右手抓到一张牌
            int j = i - 1;                          // 拿在左手的牌总是排序好的
            while (j >= 0 && array[j] > get){       // 将抓到的牌与手牌从右向左进行比较
                array[j + 1] = array[j];            // 如果该手牌比抓到的牌大，就将其向右移
                j--;
            }
            array[j + 1] = get;                     // 直到该手牌比抓到的牌小(或二者相等)，将抓到的牌插入到该手牌右边(相等元素的相对次序未变，所以插入排序是稳定的)
        }
    }

    public static void main(String[] args){
        int[] array = {6, 5, 3, 1, 8, 7, 2, 4};
        int length = array.length;
        InsertionSort insertionSort = new InsertionSort();
        insertionSort.sort(array, length);
        System.out.println("插入排序结果：");
        Arrays.stream(array).forEach(System.out::println);
    }
}

上述代码对序列{ 6, 5, 3, 1, 8, 7, 2, 4 }进行插入排序的实现过程如下：
插入排序过程
使用插入排序为一列数字进行排序的宏观过程：
插入排序宏观过程

插入排序不适合对于数据量比较大的排序应用，但是，如果需要排序的数据量很小，比如量级小于千，那么插入排序还是一个不错的选择。

插入排序的改进：二分插入排序

对于插入排序，如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的次数，我们称为二分插入排序，代码如下：

import java.util.Arrays;

/**
 * @分类              内部比较排序
 * @数据结构          数组
 * @最差时间复杂度    O(n^2)
 * @最优时间复杂度    O(nlogn)
 * @平均时间复杂度    O(n^2)
 * @所需辅助空间      O(1)
 * @稳定性            稳定
 *
 */

public class BinaryInsertionSort {
    public void sort(int[] array, int n){
        for (int i = 1; i < n; i++){
            int get = array[i];                     // 右手抓到一张扑克牌
            int left = 0;                           // 拿在左手上的牌总是排序好的，所以可以用二分法
            int right = i - 1;                      // 手牌左右边界进行初始化
            while(left <= right){                   // 采用二分法定位新牌的位置
                int mid = (left + right) / 2;
                if (array[mid] > get){
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            }

            for (int j = i - 1; j >= left; j--){    // 将欲插入新牌位置右边的牌整体向右移动一个单位
                array[j + 1] = array[j];
            }
            array[left] = get;                      // 将抓到的牌插入手牌
        }
    }

    public static void main(String[] args){
        int[] array = {5, 2, 9, 4, 7, 6, 1, 3, 8};
        int length = array.length;
        BinaryInsertionSort binaryInsertionSort = new BinaryInsertionSort();
        binaryInsertionSort.sort(array, length);
        System.out.println("二分插入排序结果：");
        Arrays.stream(array).forEach(System.out::println);
    }
}

当n较大时，二分插入排序的比较次数比直接插入排序的最差情况好得多，但比直接插入排序的最好情况要差，所当以元素初始序列已经接近升序时，直接插入排序比二分插入排序比较次数少。二分插入排序元素移动次数与直接插入排序相同，依赖于元素初始序列。

插入排序的更高效改进：希尔排序（Shell Sort）

希尔排序，也叫递减增量排序，是插入排序的一种更高效的改进版本。希尔排序是不稳定的排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能，这样可以让一个元素可以一次性地朝最终位置前进一大步，然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了（此时插入排序较快）。

假设有一个很小的数据在一个已按升序排好序的数组的末端。如果用复杂度为 $O(n^2)$ 的排序（冒泡排序或直接插入排序），可能会进行 $n$ 次的比较和交换才能将该数据移至正确位置，而希尔排序会用较大的步长移动数据，所以小数据只需进行少数比较和交换即可到正确位置。

希尔排序的代码如下：

import java.util.Arrays;

/**
 * @分类              内部比较排序
 * @数据结构          数组
 * @最差时间复杂度    根据步长序列的不同而不同。已知最好的为O(n(logn)^2)
 * @最优时间复杂度    O(n)
 * @平均时间复杂度    根据步长序列的不同而不同。
 * @所需辅助空间      O(1)
 * @稳定性            不稳定
 *
 */

public class ShellSort {
    public void sort(int[] array, int n){
        int h = 0;
        while (h <= n){
            h = h * 3 + 1;
        }
        while (h >= 1){                                  // 生成初始量
            for (int i = h; i < n; i++){
                int j = i - h;
                int get = array[i];
                while (j >= 0 && array[j] > get){
                    array[j + h] = array[j];
                    j = j - h;
                }
                array[j + h] = get;
            }
            h = (h - 1) / 3;                            // 递减增量
        }
    }

    public static void main(String[] args){
        int[] array = {5, 2, 9, 4, 7, 6, 1, 3, 8};  // 从小到大希尔排序
        int length = array.length;
        ShellSort shellSort = new ShellSort();
        shellSort.sort(array, length);
        System.out.println("希尔排序结果：");
        Arrays.stream(array).forEach(System.out::println);
    }
}

以23, 10, 4, 1的步长序列进行希尔排序：
希尔排序过程

希尔排序是不稳定的排序算法，虽然一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱。

比如序列：{ 3, 5, 10, 8, 7, 2, 8, 1, 20, 6 }，h = 2时分成两个子序列 { 3, 10, 7, 8, 20 } 和 { 5, 8, 2, 1, 6 } ，未排序之前第二个子序列中的8在前面，现在对两个子序列进行插入排序，得到 { 3, 7, 8, 10, 20 } 和 { 1, 2, 5, 6, 8 } ，即 { 3, 1, 7, 2, 8, 5, 10, 6, 20, 8 } ，两个8的相对次序发生了改变。

归并排序（Merge Sort）

归并排序是创建在归并操作上的一种有效的排序算法，效率为 $O(nlogn)$ ，1945年由冯·诺伊曼首次提出。

归并排序的实现分为递归实现与非递归（迭代）实现：

递归实现的归并排序是算法设计中分治策略的典型应用，我们将一个大问题分割成小问题分别解决，然后用所有小问题的答案来解决整个大问题。
非递归（迭代）实现的归并排序首先进行是两两归并，然后四四归并，然后是八八归并，一直下去直到归并了整个数组。

归并排序算法主要依赖归并(Merge)操作。归并操作指的是将两个已经排序的序列合并成一个序列的操作，归并操作步骤如下：

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
设定两个指针，最初位置分别为两个已经排序序列的起始位置
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针到达序列尾
将另一序列剩下的所有元素直接复制到合并序列尾

归并排序的代码如下：
import java.util.Arrays;

/**
 * @分类              内部比较排序
 * @数据结构          数组
 * @最差时间复杂度    O(nlogn)
 * @最优时间复杂度    O(nlogn)
 * @平均时间复杂度    O(nlogn)
 * @所需辅助空间      O(n)
 * @稳定性            稳定
 *
 */

public class MergeSort {
    public void merge(int[] array, int left, int mid, int right){        // 合并两个已排好序的数组A[left...mid]和A[mid + 1...right]
        int len = right - left + 1;
        int[] temp = new int[len];      // 辅助空间O(n)
        int index = 0;
        int i = left;                   // 前一数组起始元素
        int j = mid + 1;                // 后一数组起始元素
        while (i <= mid && j <= right){
            temp[index++] = array[i] <= array[j] ? array[i++] : array[j++]; // 带等号保证归并稳定性
        }
        while (i <= mid){
            temp[index++] = array[i++];
        }
        while (j <= right){
            temp[index++] = array[j++];
        }
        for (int k = 0; k < len; k++){
            array[left++] = temp[k];
        }
    }

    public void mergeSortRecursion(int[] array, int left, int right){   // 递归实现的归并排序（自顶向下）
        if (left == right){     // 当待排序的序列长度为1时，递归开始回溯，进行merge操作
            return;
        }
        int mid = (left + right) / 2;
        mergeSortRecursion(array, left, mid);
        mergeSortRecursion(array, mid + 1, right);
        merge(array, left, mid, right);
    }

    public void mergeSortIteration(int[] array, int len){       // 非递归（迭代）实现的归并排序（自底向上）
        int left, mid, right;       //  子数组索引，前一个A[left...mid]和A[mid + 1...right]
        for (int i = 1; i < len; i *= 2){       // 子数组的大小i初始为1，每轮翻倍
            left = 0;
            while (left + i < len) {      // 后一个子数组存在(需要归并)
                mid = left + i - 1;
                right = mid + 1 < len ? mid + i : len - 1;      // 后一个子数组大小可能不够
                merge(array, left, mid, right);
                left = right + 1;
            }
        }
    }

    public static void main(String[] args){
        int[] a1 = {6, 5, 3, 1, 8, 7, 2, 4};  // 从小到大归并排序
        int[] a2 = {6, 5, 3, 1, 8, 7, 2, 4};
        int len1 = a1.length;
        int len2 = a2.length;
        MergeSort mergeSort = new MergeSort();
        mergeSort.mergeSortRecursion(a1, 0, len1 - 1);      // 递归实现
        mergeSort.mergeSortIteration(a2, len2);             // 非递归实现
        System.out.println("递归实现排序结果：");
        Arrays.stream(a1).forEach(System.out::println);
        System.out.println("非递归实现排序结果：");
        Arrays.stream(a2).forEach(System.out::println);
    }
}
上述代码对序列{ 6, 5, 3, 1, 8, 7, 2, 4 }进行归并排序的实例如下：

使用归并排序为一列数字进行排序的宏观过程：

归并排序除了可以对数组进行排序，还可以高效的求出数组小和（即单调和）以及数组中的逆序对，详见这篇博文。

堆排序（Heap Sort）

堆排序是指利用堆这种数据结构所设计的一种选择排序算法。

堆是一种近似完全二叉树的结构（通常堆是通过一维数组来实现的），并满足性质，以最大堆（也叫大根堆、大顶堆）为例，其中父结点的值总是大于它的孩子节点。

我们可以很容易的定义堆排序的过程：

由输入的无序数组构造一个最大堆，作为初始的无序区
把堆顶元素（最大值）和堆尾元素互换
把堆（无序区）的尺寸缩小1，并调用 $heapify(A, 0)$ 从新的堆顶元素开始进行堆调整
重复步骤2，直到堆的尺寸为1

堆排序的代码如下：
import java.util.Arrays;

/**
 * @分类              内部比较排序
 * @数据结构          数组
 * @最差时间复杂度    O(nlogn)
 * @最优时间复杂度    O(nlogn)
 * @平均时间复杂度    O(nlogn)
 * @所需辅助空间      O(1)
 * @稳定性            不稳定
 *
 */

public class HeapSort {
    private void swap(int[] array, int front, int back){
        int temp = array[front];
        array[front] = array[back];
        array[back] = temp;
    }

    private void heapify(int[] array, int i, int size){     // 从A[i]向下进行堆调整
        int left_child = 2 * i + 1;     // 左孩子索引
        int right_child = 2 * i + 2;    // 右孩子索引
        int max = i;                    // 选出当前结点与其左右孩子三者之中的最大值
        if (left_child < size && array[left_child] > array[max]){
            max = left_child;
        }
        if (right_child < size && array[right_child] > array[max]){
            max = right_child;
        }
        if (max != i){
            swap(array, i, max);        // 把当前结点和它的最大（直接）子节点进行交换
            heapify(array, max, size);  // 递归调用，继续从当前结点向下进行堆调整
        }
    }

    private int buildHeap(int[] array, int n){          // 建堆，时间复杂度O(n)
        int heap_size = n;
        for (int i = heap_size / 2 - 1; i >= 0; i--){   // 从每一个非叶结点开始向下进行堆调整
            heapify(array, i, heap_size);
        }
        return heap_size;
    }

    public void sort(int[] array, int n){
        int heap_size = buildHeap(array, n);        // 建立一个最大堆
        while (heap_size > 1){                  // 堆（无序区）元素个数大于1，未完成排序
            // 将堆顶元素与堆的最后一个元素互换，并从堆中去掉最后一个元素
            // 此处交换操作很有可能把后面元素的稳定性打乱，所以堆排序是不稳定的排序算法
            swap(array, 0, --heap_size);
            heapify(array, 0, heap_size);       // 从新的堆顶元素开始向下进行堆调整，时间复杂度O(logn)
        }
    }

    public static void main(String[] args){
        int[] array = {5, 2, 9, 4, 7, 6, 1, 3, 8};  // 从小到大堆排序
        int len = array.length;
        HeapSort heapSort = new HeapSort();
        heapSort.sort(array, len);
        System.out.println("堆排序结果：");
        Arrays.stream(array).forEach(System.out::println);
    }
}
堆排序算法的演示：

动画中在排序过程之前简单的表现了创建堆的过程以及堆的逻辑结构。
堆排序是不稳定的排序算法，不稳定发生在堆顶元素与 $A[i]$ 交换的时刻。

比如序列{ 9, 5, 7, 5 }，堆顶元素是9，堆排序下一步将9和第二个5进行交换，得到序列 { 5, 5, 7, 9 }，再进行堆调整得到{ 7, 5, 5, 9 }，重复之前的操作最后得到{ 5, 5, 7, 9 }从而改变了两个5的相对次序。

快速排序（Quick Sort）

快速排序是由东尼 · 霍尔所发展的一种排序算法。
在平均状况下，排序 $n$ 个元素要 $O(nlogn)$ 次比较。
在最坏状况下则需要 $O(n^2)$ 次比较，但这种状况并不常见。
事实上，快速排序通常明显比其他 $O(nlogn)$ 算法更快，因为它的内部循环可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治策略(Divide and Conquer)来把一个序列分为两个子序列，步骤为：

从序列中挑出一个元素，作为基准（pivot）
把所有比基准值小的元素放在基准前面，所有比基准值大的元素放在基准的后面（相同的数可以到任一边），这个称为分区（partition）操作。
对每个分区递归地进行步骤 1 ~ 2，递归的结束条件是序列的大小是 0 或 1，这时整体已经被排好序了。

快速排序的代码如下：
import java.util.Arrays;

/**
 * @分类              内部比较排序
 * @数据结构          数组
 * @最差时间复杂度    每次选取的基准都是最大（或最小）的元素，导致每次只划分出了一个分区，需要进行n-1次划分才能结束递归，时间复杂度为O(n^2)
 * @最优时间复杂度    每次选取的基准都是中位数，这样每次都均匀的划分出两个分区，只需要logn次划分就能结束递归，时间复杂度为O(nlogn)
 * @平均时间复杂度    O(nlogn)
 * @所需辅助空间      主要是递归造成的栈空间的使用(用来保存left和right等局部变量)，取决于递归树的深度，一般为O(logn)，最差为O(n)
 * @稳定性            不稳定
 *
 */

public class QuickSort {
    private void swap(int[] array, int front, int back){
        int temp = array[front];
        array[front] = array[back];
        array[back] = temp;
    }

    private int partition(int[] array, int left, int right){     // 划分函数
        int pivot = array[right];       // 这里每次都选择最后一个元素作为基准
        int tail = left - 1;            // tail为小于基准的子数组最后一个元素的索引
        for (int i = left; i < right; i++){     // 遍历基准以外的其他元素
            if (array[i] <= pivot){
                swap(array, ++tail, i);
            }
        }
        swap(array, tail + 1, right);   // 最后把基准放到前一个子数组的后边，剩下的子数组既是大于基准的子数组
                                              // 该操作很有可能把后面元素的稳定性打乱，所以快速排序是不稳定的排序算法
        return tail + 1;            // 返回基准的索引
    }

    public void sort(int[] array, int left, int right){
        if (left >= right){
            return;
        }
        int pivot_index = partition(array, left, right);    // 基准的索引
        sort(array, left, pivot_index - 1);
        sort(array, pivot_index + 1, right);
    }

    public static void main(String[] args){
        int[] array = {5, 2, 9, 4, 7, 6, 1, 3, 8};  // 从小到大排序
        int len = array.length;
        QuickSort quickSort = new QuickSort();
        quickSort.sort(array, 0, len - 1);
        System.out.println("快速排序结果：");
        Arrays.stream(array).forEach(System.out::println);
    }
}
使用快速排序法对一列数字进行排序的过程：

快速排序是不稳定的排序算法，不稳定发生在基准元素与 $A[tail+1]$ 交换的时刻。
比如序列：{ 1, 3, 4, 2, 8, 9, 8, 7, 5 }，基准元素是5，一次划分操作后5要和第一个8进行交换，从而改变了两个元素8的相对次序。

Java系统提供的Arrays.sort函数，对于基础类型，底层使用快速排序，对于非基础类型，底层使用归并排序，请问是为什么？

答：
这是考虑到排序算法的稳定性。
对于基础类型，相同值是无差别的，排序前后相同值的相对位置并不重要，所以选择更为高效的快速排序，尽管它是不稳定的排序算法。
而对于非基础类型，排序前后相等实例的相对位置不宜改变，所以选择稳定的归并排序。