数据结构与算法之美-4 排序算法1

本文地址

---

目录

目录

• 目录
• 11 | 排序（上）：为什么插入排序比冒泡排序更受欢迎？
  • 如何分析一个排序算法？
    • 排序算法的执行效率
    • 排序算法的内存消耗
    • 排序算法的稳定性
  • O(n^2) 排序算法
    • 冒泡排序 Bubble Sort
    • 插入排序 Insertion Sort
    • 选择排序 Selection Sort
  • 解答开篇

11 | 排序（上）：为什么插入排序比冒泡排序更受欢迎？

• 算法时间空间复杂度
• 算法执行过程动态图

最经典的、最常用的8个排序算法：冒泡排序、插入排序、选择排序、归并排序、快速排序、计数排序、基数排序、桶排序。

如何分析一个排序算法？

排序算法的执行效率

• 最好情况、最坏情况、平均情况时间复杂度
  • 对于要排序的数据，有序度不同时对排序的执行时间是有影响的，我们要知道排序算法在不同数据下的性能表现。
• 时间复杂度的系数、常数 、低阶
  • 时间复杂度反映的是数据规模 n 很大的时候的一个增长趋势，所以它表示的时候会忽略系数、常数、低阶。
  • 但是实际的软件开发中，我们排序的可能是 10 个、100 个、1000 个这样规模很小的数据，此时，在对同一阶时间复杂度的排序算法性能对比的时候，我们就要把系数、常数、低阶也考虑进来。
• 比较次数和交换（或移动）次数
  • 基于比较的排序算法的执行过程，会涉及元素比较大小、元素交换或移动两种操作。
  • 在分析排序算法的执行效率的时候，应该把比较次数和交换（或移动）次数也考虑进去。

排序算法的内存消耗

原地排序算法，就是特指空间复杂度是 O(1) 的排序算法。

除了存储数据本身的空间外，不需要额外的辅助存储空间

排序算法的稳定性

稳定性：如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间原有的先后顺序不变。

算法稳定性的用处：多次排序中，下一次排序需要依赖上一次排序的稳定结果。

O(n^2) 排序算法

• 平均时间复杂度都是 O(n^2)，都是基于比较的排序算法
• 空间复杂度都是 O(1)，都是原地排序算法
• 冒泡排序和插入排序是稳定的排序算法，选择排序不是稳定的排序算法

这三种排序算法中，冒泡排序、选择排序可能就纯粹停留在理论的层面了，学习的目的也只是为了开拓思维，实际开发中应用并不多，但是插入排序还是挺有用的，有些编程语言中的排序函数的实现原理会用到插入排序算法。

冒泡排序 Bubble Sort

冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序工作。

public void bubbleSort(int[] a, int n) {
    if (n <= 1) {
        return;
    }

    for (int i = 0; i < n; ++i) {
        // 提前退出冒泡循环的标志位
        boolean flag = false;
        for (int j = 0; j < n - i - 1; ++j) {
            if (a[j] > a[j + 1]) { // 交换
                int tmp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = tmp;
                flag = true;  // 表示有数据交换
            }
        }
        if (!flag) {
            break;  // 当某次冒泡操作已经没有数据交换时，说明已经达到完全有序，不用再继续执行后续的冒泡操作
        }
    }
}

冒泡排序性能分析：

• 冒泡的过程只涉及相邻数据的交换操作，只需要常量级的临时空间，所以它的空间复杂度为 O(1)，是一个原地排序算法。
• 在冒泡排序中，只有交换才可以改变两个元素的前后顺序。为了保证冒泡排序算法的稳定性，当有相邻的两个元素大小相等的时候，我们不做交换，相同大小的数据在排序前后不会改变顺序，所以冒泡排序是稳定的排序算法。
• 最好情况下，要排序的数据已经是有序的了，我们只需要进行一次冒泡操作，就可以结束了，所以最好情况时间复杂度是 O(n)。
• 最坏情况下，要排序的数据刚好是倒序排列的，我们需要进行 n 次冒泡操作，所以最坏情况时间复杂度为 O(n^2)。
• 平均情况下，需要 n*(n-1)/4 次交换操作，比较操作肯定要比交换操作多，而复杂度的上限是 O(n^2)，所以平均情况下的时间复杂度就是 O(n^2)。

对于一个给定的初始序列，冒泡排序算法不管怎么优化，元素交换的次数是一个固定值(因为其不涉及类似快排那种选择分隔点的操作)。

插入排序 Insertion Sort

问题：一个有序的数组，我们往里面添加一个新的数据后，如何继续保持数据有序呢？

很简单，我们只要遍历数组，找到数据应该插入的位置将其插入即可。

对于一组静态数据，我们也可以借鉴上面讲的插入方法，来进行排序，于是就有了插入排序算法。

• 首先，我们将数组中的数据分为两个区间，已排序区间和未排序区间。
• 初始已排序区间只有一个元素，就是数组的第一个元素。
• 插入算法的核心思想是：取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一直有序。
• 重复这个过程，直到未排序区间中元素为空，算法结束。

插入排序包含元素的比较、元素的移动两种操作。当我们需要将一个数据 a 插入到已排序区间时，需要拿 a 与已排序区间的元素依次比较大小，找到合适的插入位置。找到插入点之后，我们还需要将插入点之后的元素顺序往后移动一位，这样才能腾出位置给元素 a 插入。

public void insertionSort(int[] a, int n) {
    if (n <= 1) {
        return;
    }

    for (int i = 1; i < n; ++i) {
        int value = a[i];
        int j = i - 1;
        // 查找插入的位置
        for (; j >= 0; --j) {
            if (a[j] > value) {
                a[j + 1] = a[j];  // 数据移动
            } else {
                break;
            }
        }
        a[j + 1] = value; // 插入数据
    }
}

• 插入排序算法的运行并不需要额外的存储空间，所以空间复杂度是 O(1)，也就是说，这是一个原地排序算法。
• 在插入排序中，对于值相同的元素，我们可以选择将后面出现的元素，插入到前面出现元素的后面，这样就可以保持原有的前后顺序不变，所以插入排序是稳定的排序算法。
• 最好是时间复杂度为 O(n)，最坏情况时间复杂度为 O(n^2)，平均时间复杂度为 O(n^2)
• 对于一个给定的初始序列，对于不同的查找插入点方法（从头到尾、从尾到头），元素的比较次数是有区别的，但移动操作的次数是固定的。

选择排序 Selection Sort

选择排序算法的实现思路和插入排序类似，也分已排序区间和未排序区间：

• 插入排序，是找到插入点之后，原本插入点及其之后的元素后移
• 选择排序，是找到插入点之后，待插入的最小元素与原本插入点位置的元素做交换

• 选择排序空间复杂度为 O(1)，是一种原地排序算法。
• 因为不管原来的顺序是什么，每次都要通过全部比较一次后找到最小值，所以选择排序的最好情况时间复杂度、最坏情况和平均情况时间复杂度都为 O(n^2)
• 选择排序是一种不稳定的排序算法，选择排序每次都要找剩余未排序元素中的最小值，并和前面的元素交换位置，这样破坏了稳定性。

解答开篇

• 虽然冒泡排序不管怎么优化，元素交换的次数是一个固定值，是原始数据的逆序度；插入排序不管怎么优化，元素移动的次数也等于原始数据的逆序度。
• 但是冒泡排序的数据交换比插入排序的数据移动复杂：冒泡排序需要 3 个赋值操作，而插入排序只需要 1 个。
• 所以，插入排序性能相对更好一点。另外，插入排序的算法思路也有很大的优化空间，我们只是讲了最基础的一种。

实验：针对上面的冒泡排序和插入排序的 Java 代码，我写了一个性能对比测试程序，随机生成 10000 个数组，每个数组中包含 200 个数据，然后分别用冒泡和插入排序算法来排序
结果：冒泡排序算法大约 700ms 才能执行完成，而插入排序只需要 100ms 左右就能搞定！

2021-08-06