排序算法

概述

稳定性

归并排序、冒泡排序、插入排序、基数排序是稳定的

选择排序、快速排序、希尔排序、堆排序是不稳定的

时间复杂度

最基础的四个算法：冒泡、选择、插入、快排中，快排的时间复杂度最小O(n*log2n)，其他都是O（n2）

排序法	平均时间	最差情形	稳定度	额外空间	备注
冒泡	O(n^2^)	O(n^2^)	稳定	O(1)	n小时较好
选择	O(n^2^)	O(n^2^)	不稳定	O(1)	n小时较好
插入（简单）	O(n^2^)	O(n^2^)	稳定	O(1)	大部分已排序时较好
基数	O(logRB)	O(logRB)	稳定	O(n)	B是真数(0-9)，R是基数(个十百)
希尔排序	O(nlogn)	O(n^s^) 1<s<2	不稳定	O(1)	s是所选分组
快速	O(nlogn)	O(n^2^)	不稳定	O(nlogn)	n大时较好
归并	O(nlogn)	O(nlogn)	稳定	O(1)	n大时较好
堆	O(nlogn)	O(nlogn)	不稳定	O(1)	n大时较好

• 常见的排序算法的时间复杂度都无法到达O(logN)级别
• 稳定与不稳定指的是排序前后会不会改变两个相同数字的前后顺序
• 稳定的排序算法有：冒泡、插入、基数、归并 （毛茶机柜）
• 不稳定的排序算法有：选择、希尔、快速、堆 （快点把希尔择性的堆**起来）

高级排序算法，四种高级排序算法的平均时间复杂度均可达到O(nlogN)

• 希尔排序
• 快速排序
• 归并排序（稳定）
• 堆排序

快速排序，出现最坏情况的场景，又因为快速排序本质上是一种交换排序，当最坏情况，时间复杂度会退化到O(N^2^)

这个答案还得看枢轴（pivot）的选择策略。在快速排序的早期版本中呢，最左面或者是最右面的那个元素被选为枢轴，那最坏的情况就会在下面的情况下发生啦：

1）数组已经是正序（same order）排过序的。 2）数组已经是倒序排过序的。 3）所有的元素都相同（1、2的特殊情况）

因为这些案例在用例中十分常见，所以这个问题可以通过要么选择一个随机的枢轴，或者选择一个分区中间的下标作为枢轴，或者（特别是对于相比更长的分区）选择分区的第一个、中间、最后一个元素的中值作为枢轴。有了这些修改，那快排的最差的情况就不那么容易出现了，但是如果输入的数组最大（或者最小元素）被选为枢轴，那最坏的情况就又来了。

3.排序算法的思想：

(6)基数排序 基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以其是稳定的排序算法。

(7)希尔排序(shell) 希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。

(8)堆排序 我们知道堆的结构是节点i的孩子为2i和2i+1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n的序列，堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n/2-1, n/2-2, ...1这些个父节点选择元素时，就会破坏稳定性。有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法

排序算法的应用场景

数据量较少

​ 插入排序

数据基本有序

​ 插入排序

海量数据

​ 堆排序

前n个数据

​ 堆排序

空间大资源足，要求时间效率

​ 归并排序

不知道用什么

​ 快速排序

从平均时间性能而言，快速排序最佳，其所需时间是最省，但快速排序在最坏的情况下的时间性能不如堆排序和归并排序。

当空间大资源足，要求时间效率时，可采用归并排序。

海量数据用堆排序

​ 堆排序虽然较之快排慢一些，但特别适合海量数据的排序。如在100万个数据里面找出前1000大的数据。可以用建立一个小顶堆存储1000元素。

当序列中的记录基本有序或n值较小，插入排序是最佳的排序方法。

基数排序最适用于基数很大但关键字较小的序列。

冒泡排序

冒泡排序的基本思想

是相邻元素之间的比较和交换，两重循环O(n2)；所以，如果两个相邻元素相等，是不会交换的。所以它是一种稳定的排序方法

冒泡排序的时间复杂度

O(n^2^)

冒泡排序是稳定的吗

是

冒泡排序的应用场景

冒泡排序的代码

public class BubbleSort08 {
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            boolean flag = true;
            for (int j = 0; j < arr.length - 1; j++) {
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = false;
                }
            }
            if(flag){
                break;
            }
        }
    }
    public static void main(String[] args) {
        int[] arr = new int[]{11,8,9,1,22,-5,3};
        System.out.println("排序前："+ Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println("排序后："+Arrays.toString(arr));
    }
}

选择排序

选择排序的思想

每个元素都与第一个元素相比，产生交换，两重循环O(n^2^)；举个栗子，5 8 5 2 9，第一遍之后，2会与5交换，那么原序列中两个5的顺序就被破坏了。所以不是稳定的排序算法

选择排序的时间复杂度

O(n^2^)

选择排序的是稳定的吗

不是。

举个例子：arr = {5, 8, 5, 2, 9} 第一次排序后 arr = {2, 8, 5, 5, 9} 原序列中的两个5的顺序变了，所以不是稳定的排序算法

选择排序的应用场景

public class SelectSort10 {
    public static void selectSort(int[] arr){
        for(int i = 0; i < arr.length-1;i++){
            int min = arr[i];
            int minIndex = i;
            boolean flag = false;
            for(int j = i + 1;j < arr.length;j++){
                if(arr[j] < min){
                    minIndex = j;
                    min = arr[j];
                    flag = true;
                }
            }
            if(flag){
                arr[minIndex] = arr[i];
                arr[i] = min;

            }
        }
    }
    public static void main(String[] args){
        int[] arr = new int[]{3,3,34,6,-1,2,65};
        System.out.println("排序前："+ Arrays.toString(arr));
        selectSort(arr);
        System.out.println("排序后："+ Arrays.toString(arr));
    }
}

插入排序

插入排序的思想

​ 插入排序的基本思想是：把n个待排序的元素看成是一个有序表和一个无序表，开始的时候有序表只包含以额元素，无序表中包含有n-1个元素。排序的过程中每次从无序表中取出第一个元素，将他与有序表的最后一个元素开始比较，**（1）如果比他大就直接插在后面，如果；（2）否则就一直向前找它应该插入的位置；（3）如果遇到了一个和插入元素相等的，则把这个元素放在这个相等元素的后面。**所以元素的顺序没有改变，即该算法是稳定的。

缺点：当需要插入的数字是较小的数字时，数字后移动的次数明显增多

插入排序的时间复杂度

O(n^2^)

插入排序是稳定的吗

是，**（1）如果比他大就直接插在后面，如果；（2）否则就一直向前找它应该插入的位置；（3）如果遇到了一个和插入元素相等的，则把这个元素放在这个相等元素的后面。**所以元素的顺序没有改变，即该算法是稳定的

插入排序的应用场景

（1）数据量较少

（2）数据基本有序

插入排序示例

插入排序的代码

public static void insertSort(int[] arr) {
        //n位数的数组只需要经过n-1次排序
        for (int i = 0; i < arr.length - 1; i++) {
            //存储insertVal防止后面丢失
            int insertVal = arr[i+1];
            //保存insertIndex，而不用i，因为i是很重要变量，不可以直接对i进行加减
            //insertIndex指的是无序表的第一个数字的下标
            int insertIndex = i;
            //将无序表的第一个数字一次跟有序表的数字进行比较，如果无序表的第一个数字小于有序表的数字
            //则将后面index前面数字的值赋值给后面的数字
            //index--
            //便于下一个有序表的数字进行比较
            while(insertIndex >= 0 && insertVal < arr[insertIndex]){
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            arr[insertIndex + 1] = insertVal;
        }
    }

基数排序

基数排序的思想

​ 基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依此类推，直到最高位。基数排序基于分别排序，分别收集，所以是稳定的排序算法

基数排序的时间复杂度

基数 O(logRB) O(logRB) 稳定 O(n) B是真数(0-9)，R是基数(个十百)

基数排序概述

基数排序（radix sort）属于“分配式”排序（distribution sort）

基数排序属于稳定的排序

基数排序是经典的时间换空间的方式，占用内存很大，当对海量的数据进行排序的时候容易造成OutOfMemoryError

基数排序的过程

第一轮排序： （1）将每个元素的个位数取出，然后看这个数应该放在哪个对应的桶 （2）按照这个桶的顺序（按照以为数组的下标依次取出数据，放入原来的数组中）

第二轮排序： （1）将每个元素的十位数取出，然后看这个数应该放在哪个对应的桶 （2）按照这个桶的顺序（按照以为数组的下标依次取出数据，放入原来的数组中）

第三轮排序： （1）将每个元素的百位数取出，然后看这个数应该放在哪个对应的桶 （2）按照这个桶的顺序（按照以为数组的下标依次取出数据，放入原来的数组中）

归并排序

归并排序的基本思想

​ 归并排序是把数组递归的分成短数组，满足如下条件即为递归出口：短数组只有一个元素（认为直接有序）。然后把各个有序的数组合并成一个有序的长数组，不断合并直到原数组全部排好序。

归并排序的时间复杂度

O(nlogn)

归并排序是稳定的吗

​ 是。可以发现，在1个或者2个元素的时候，1个元素不会发生交换。2个元素如果大小相等也不会发生交换，这不会破坏稳定性。

希尔排序

希尔排序的思想

​ 希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的

希尔排序的时间复杂度

平均：O(nlogn) 最差O(n^s^) 1<s<2

希尔排序的是稳定的吗

不是。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的

堆排序

堆排序的概述

1. 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏、最好、平均时间复杂度均为O(nlogn) （又称为：线性对数阶），也是不稳定的排序

堆的性质

• 堆是一棵完全二叉树
• 堆具有如下性质：（1）每个父结点的值都大于其左右孩子结点的值；（2）堆没有要求左右孩子结点值得大小关系，这点与二叉搜索树/排序树/avl树/红黑树不一致
• 大顶堆：每个父结点的值都大于左右孩子结点的值
• 小顶堆：每个父结点的值都小于左右孩子结点的值
• 最后一个非叶子结点的序号为 n/2 -1

扩展

堆排序（完全二叉树）最后一个非叶子节点的序号是n/2-1的原因

堆排序是基于完全二叉树实现的，在将一个数组调整成一个堆的时候，关键之一的是确定最后一个非叶子节点的序号，这个序号为n/2-1，n为数组的长度。但是为什么呢？

可以分两种情形考虑：

①堆的最后一个非叶子节点若只有左孩子

②堆的最后一个非叶子节点有左右两个孩子

完全二叉树的性质之一是：如果节点序号为i，在它的左孩子序号为2i+1，右孩子序号为2i+2。

对于①左孩子的序号为n-1，则n-1=2*i+1，推出i=n/2-1；

对于②左孩子的序号为n-2，在n-2=2i+1，推出i=(n-1)/2-1；右孩子的序号为n-1，则n-1=2i+2，推出i=(n-1)/2-1；

很显然，当完全二叉树最后一个节点是其父节点的左孩子时，树的节点数为偶数；当完全二叉树最后一个节点是其父节点的右孩子时，树的节点数为奇数。

根据java语法的特征，整数除不尽时向下取整，则若n为奇数时(n-1)/2-1=n/2-1。

因此对于②最后一个非叶子节点的序号也是n/2-1。

得证。

显然序号是从0开始的。

引自：www.cnblogs.com/malw/p/1054…

同时，我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这个样子

该数组从逻辑上讲就是一个堆结构，我们用简单的公式来描述一下堆的定义就是：

大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]

小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了

堆排序的基本思想

1. 将待排序的序列构造成一个大顶堆
2. 此时，整个序列的最大值就是堆顶的根节点
3. 将其与末尾元素进行交换，此时末尾就为最大值
4. 然后将剩余n-1个元素重新构造成一个堆，这样就会得到n个元素的小值，如此反复执行，就能得到一个有序序列了

堆排序示例

步骤一 构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。

　　a.假设给定无序序列结构如下

2.此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点 arr.length/2-1=5/2-1=1，也就是下面的6结点），从左至右，从下至上进行调整。

4.找到第二个非叶节点4，由于[4,9,8]中9元素最大，4和9交换。

这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中6最大，交换4和6。

此时，我们就将一个无需序列构造成了一个大顶堆。

步骤二 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

a.将堆顶元素9和末尾元素4进行交换

b.重新调整结构，使其继续满足堆定义

c.再将堆顶元素8与末尾元素5进行交换，得到第二大元素8.

后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序

代码实现

public class HeapSort00 {
    public static void main(String[] args) {
        //升序：大顶堆 ；降序；小顶堆
        int[] arr = {4, 6, 8, 5, 9};
        heapSort(arr);
    }

    //编写一个堆排序的方法
    public static void heapSort(int[] arr) {
        int temp = 0;
        System.out.println("堆排序！！");
        //从第一个非叶子结点从下至上，从右至左调整结构
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjustHeap(arr, i, arr.length);
        }

        //调整堆结构+交换堆顶元素与末尾元素，直到整个序列有序
        for (int j = arr.length - 1; j > 0; j--) {
            //将堆顶元素与末尾元素进行交换
            temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            //重新对堆进行调整
            adjustHeap(arr, 0, j);
        }
        System.out.println("数组：" + Arrays.toString(arr));
    }

    /**
     * 功能：完成 将i对应的非子结点的树调整成大顶堆
     *
     * @param arr    待调整的数组
     * @param i      非叶子节点在数组中的索引
     * @param length 表示对多少个元素进行调整，length是在逐渐的减少
     */
    public static void adjustHeap(int[] arr, int i, int length) {
        //非叶子结点的值
        int temp = arr[i];
        //开始调整
        /**
         * 初始值：int k = i * 2 + 1 表示索引为i的结点的左子结点的索引
         * 步长：k = k * 2 + 1表示选取孩子结点的左孩子结点,继续向下筛选
         */
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            //先比较左子结点和右子节点的值
            //arr[k] < arr[k+1]说明左子节点的值小于右子节点
            //if需要满足两个条件，首先 k+1<length保证数组不会越界，第二个就是右子结点的值大于左子节点的值
            if (k + 1 < length && arr[k] < arr[k + 1]) {
                k++;//k指向右子节点
            }
            //此时比较右子结点和父节点的值
            if (arr[k] > temp) {//如果子节点大于父节点
                arr[i] = arr[k];//把较大的子节点的值赋给当前的节点
                i = k;//让i指向k，继续循环比较
            } else {
                // 如果父结点的值已经大于孩子结点的值，则直接结束
                break;
            }
        }
        //当for循环结束后，我们已经将以i为父节点的这棵树的最大值放在了最顶上（子树的最顶上）
        arr[i] = temp;//将temp放到调整后的位置
    }
}

总结

1. 将无序序列构建成一个堆，根据升序降序的需求选择构建大顶堆或者小顶堆
2. 将堆顶元素与末尾元素进行交换，将最大元素“沉”到数组末端
3. 重新调整结构，使其满足堆的定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序

使用场景

==优先队列通常用堆排序来实现==

快速排序

blog.csdn.net/sinat_20177…

快速排序的思想

​ 随机找出一个数（一般找的是第一个数），把它插入一个位置，使得它左边的数字都比它小，它右边的数字都比它大。这样就将一个数组分成了两个子数组，然后再按照同样的方法把子数组再分成更小的子数组，直到不能分解为止

示例数组

a[10]={6，1，2，7，9，3，4，5，10，8}

基准值：a[0] = 6

执行步骤：将数组中小于6的数字放在6的左边，将数组中大于6的数字放在右边

在数组上设置两个哨兵i 和 哨兵 j，i指向第一个元素也就是a[0] ， j指向最后一个元素，也就是a[10]

首先哨兵j开始出动，在移动的过程中，如果发现比6大的数字，就一直移动（j--）直到找到一个小于6的数字停下来

接下来，哨兵i开始出动，在移动的过程中给，如果发现比6小的数组，就一直移动（i++），直到找到一个大于6的数字停下来

经过这一轮循环，哨兵i和j分别停在了 7 以及 5的位置

此时需要将右边比6小的5 与 左边中比6 大的7 交换

交换后如图

此时第一次交换结束，但是由于第此时哨兵i和哨兵j还没有相遇，所以重复执行刚才的操作

如图所示

第二次交换结束后，哨兵i和哨兵j还是没有碰面（本质上是没有将数组遍历完全）

接下来，哨兵j继续执行（j--）的操作，发现3 < 6，所以哨兵j停留在3的上面

然后i继续执行（i++）向右移动的操作，此时发现i==j了，那么这一轮的遍历完全，遍历也就结束了

接着将a[i] 的值与 基准（数组的第一个位置）的值进行交换

那么数组就变成了以6为分界的数组，在6的左边比6小，在6的右边比6大