11 排序1：为什么插入排序比冒泡排序更受欢迎？

本系列是学习 数据结构与算法之美  11 排序1：为什么插入排序比冒泡排序更受欢迎？

问题：插入排序和冒泡排序的时间复杂度相同，都是 O(n2),在实际的软件开发里，为什么我们更倾向于使用插入排序算法而不是冒泡排序算法呢？

一、如何分析一个“排序算法”？
（一）排序算法的执行效率
1、最好情况、最坏情况、平均情况时间复杂度
还要说出最好、最坏时间复杂度对应的要排序的原始数据是什么样的。
为什么要区分这三种时间复杂度？1 为了好对比；2 对于要排序的数据，有的接近有序，有的完全无需。有序度不用的数据，对于排序的执行时间有影响，我们要知道排序算法在不同数据下的性能表现。

2、时间复杂度的系数、常数、低阶
时间复杂度反应的是数据规模n很大的时候的一个增长趋势，所以它表示的时候会忽略系数、常数、低阶。但在实际软件开发中，排序的可能是10、100、1000个这样规模小的数据。

3、比较次数和交换（或移动）次数

（二）排序算法的内存消耗
原地排序（Sorted in place）.原地排序算法，特指空间复杂度时O(1)的排序算法。

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

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

// 冒泡排序，a 表示数组，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;  // 没有数据交换，提前退出
  }
}

1、冒泡排序是原地排序算法么？
冒泡的过程只涉及相邻数据的交换操作，只需要常量级的临时空间，所以它的空间复杂度为O(1),是一个原地排序算法。
2、冒泡排序是稳定的排序算法么？
在冒泡排序中，只有交换才可以改变两个元素的前后顺序。为了保证冒泡排序算法的稳定性，当有相邻的两个元素大小相等的时候，我们不做交换，相同大小的数据在排序前后不会改变顺序，所以冒泡排序是稳定的排序算法。
3、冒泡排序的时间复杂度是多少？
最好情况 1,2,3,4,5,6  1次冒泡 时间复杂度 O(n)
最坏情况 6,5,4,3,2,1  6次冒泡 时间复杂度 O(n2)

平均时间复杂度就是加权平均期望时间复杂度，分析的时候要结合概率论的知识。
对于包含n个数据的数组，这n个数据就有n!中排列方式。不同的排列方式，冒泡排序执行的时间肯定是不同的。如果用概率论方法定量分析平均时间复杂度，涉及的数学推理和极端就会很复杂。还有一种思路，通过“有序度”和“逆序度”这两个概念来进行分析。

“有序度”是数组中具有有序关系的元素对的个数。有序元素用数学表达式表示是这样：
有序元素对：a[i] <= a[j], 如果 i < j。

逆序元素对：a[i] > a[j], 如果 i < j。

逆序度 = 满有序度 - 有序度
排序的过程就是增加有序度，减少逆序度的过程，最后达到满有序度

冒泡排序包含两个操作原子，比较和交换。每交换一次，有序度就加1。不管算法
怎么改进，交换次数总是确定的，即为逆序度，也就是n*(n-1)/2-初始有序度。

对于包含n个数据的数组进行冒泡排序，平均交换次数是多少呢？最坏情况下，初始状态的有序度是0，所以要进行n*(n-1)/2次交换。最好情况，初始状态的有序度是n*(n-1)/2，不需要进行交换。我们可以取中间值n*(n-1)/4，来表示初始有序度既不是很高也不是很低的平均情况。

换句话说，平均情况下，需要n*(n-1)/4次交换操作，比较操作肯定要比交换操作多，而复杂度的上限是O(n2),所以平均情况下的时间复杂度就是O(n2).

这个平均时间复杂度推导过程其实并不严格，但是很多时候很实用，毕竟概率论的定量分析太复杂，不太好用。快排时，还会用到。

三、插入排序 Insertion Sort
首先，我们将数组中的数据分为两个区间，已排序区间和未排序区间。初始已排序区间只有一个元素，就是数组的第一个元素。插入算法的核心思想是取未排序区间中的元素，在已排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一致有序。重复这个过程，直到未排序区间中元素为空，算法结束。
插入排序也包好两种操作，一是元素的比较，一是元素的移动。当我们需要将一个数据a插入到已排序区间时，需要拿a与已排序区间的元素依次比较大小，找到合适的插入位置。找到插入点之后，还需要将插入点之后的元素顺序往后移动一位，这样才能腾出位置给元素a插入。

对于不同的查找插入点方法（从头到尾、从尾到头），元素的比较次数是有区别的。但对于一个给定的初始序列，移动操作的次数总是固定的，就等于逆序度。

为什么说移动次数就等等于逆序度呢？满有序度是n*(n-1)/2=15，初始序列的有序度是5，所以逆序度是10。插入排序中，数据移动的个数总和也等于10 = 3+3+4.
 

// 插入排序，a 表示数组，n 表示数组大小
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; // 插入数据
  }
}

1、插入排序是原地排序算法么？
不需要额外的存储空间，所以空间复杂度是O(1),是一个原地排序算法。
2、插入排序是稳定的排序算法么？ 是
3、插入排序的时间复杂度是多少？
最好 O(n)
最坏 O(n2)
在数组中插入一个数据的平均时间复杂度是 O(n).所以对于插入排序来说，每次插入操作都相当于在数组中插入一个数据，循环执行n次插入操作，所以平均时间复杂度为O(n2).

四、选择排序 Selection Sort
选择排序算法的实现思路类似插入排序，也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。
1、选择排序是原地排序算法么？是一个原地排序算法。
2、选择排序是稳定的排序算法么？不是,选择排序每次都要找剩余未排序元素中的最小值，并和前面的元素交换位置，这样破坏了稳定性。正是因此，相对于冒泡排序和插入排序，选择排序稍微逊色。
3、选择排序的时间复杂度是多少？ 最好、最坏和平均情况时间复杂度都是O（n2）.

五、问题：插入排序和冒泡排序的时间复杂度相同，都是 O(n2),在实际的软件开发里，为什么我们更倾向于使用插入排序算法而不是冒泡排序算法呢？

冒泡排序和插入排序不管怎么优化，元素移动的次数是固定值，是原始数组的逆序度。
但是从代码实现上，冒泡排序的数据交换要比插入排序的数据移动要复杂，冒泡排序需要3个赋值操作，而插入排序只需要1个
冒泡排序中数据的交换操作：

冒泡排序中数据的交换操作：
if (a[j] > a[j+1]) { // 交换
   int tmp = a[j];
   a[j] = a[j+1];
   a[j+1] = tmp;
   flag = true;
}

插入排序中数据的移动操作：
if (a[j] > value) {
  a[j+1] = a[j];  // 数据移动
} else {
  break;
}

我们把执行一个赋值语句的时间粗略记为单位时间 unit_time，然后分别用冒泡排序和插入排序对同一个逆序度是K的数组进行排序。用冒泡排序，需要K次交换操作，每次需要3个赋值语句，所以交换操作总耗时是3*K单位时间。而插入排序中数据移动操作只需要K个单位时间。