齐姐漫画：排序算法（一）

插入排序

借用《算法导论》里的例子，就是咱们打牌的时候，每新拿一张牌都会把它按顺序插入，这，其实就是插入排序。

齐姐声明：虽然咱们用打牌的例子，可是可不能学胡适先生啊。

对于数组来讲怎么作呢？

有一个重要的思想，叫作挡板法，就是用挡板把数组分红两个区间：

• 挡板左边：已排序
• 挡板右边：未排序

那么排序分三步走：

1. 最初挡板是在数组的最左边，保证已排序区间里一个数都没有，或者也能够包含一个数啦；
2. 核心思想就是：

依次遍历未排序区间里的元素，在已排序区间里找到正确的位置插入；

1. 重复这个过程，直到未排序区间为空。

举个例子：{5, 2, 1, 0}

第一步，挡板最初在这里：

第二步，
把 2 插入已排序区间的正确位置，变成：

重复这个步骤，把 1 排好：

最后把 0 排好：

那代码也很简单：

public void insertionSort(int[] input) {
    if(input == null || input.length <= 1) {
        return;
    }
    for(int i = 1; i < input.length; i++) {
        int tmp = input[i];
        int j = i - 1;
        while(j >= 0 && input[j] > tmp) {
            input[j+1] = input[j];
            j --;
        }
        input[j+1] = tmp;
    }
}

咱们来分析一下这个算法的时空复杂度。

时间复杂度

关于时间复杂度大 O 有两个要点：

• 是描述随着自变量的增加，所需时间的增加率；

• 是渐近线复杂度，就是说

  • 不看系数
  • 只看最高阶项

那么咱们关心的 worst case 的状况就是：
若是数组是近乎倒序的，每次插入都要在数组的第一个位置插入，那么已排序区间内的全部的元素都要日后移动一位，这一步平均是 O(n)，那么重复 n 次就是 O(n^2).

空间复杂度

重点是一个峰值的概念，并非累计使用的空间。

这里是 O(1) 没什么好说的。

引入一个概念：sorted in place，也就是原地排序。

原地排序就是指空间复杂度为 O(1) 的算法，由于没有占用额外的空间，就是原地打转嘛。

其实 in-place 的思想并非只在排序算法里有，只不过排序算法是一个最广为人知的例子罢了。本质上就是一个节省使用空间的思想。

可是对于排序算法，只分析它的时空复杂度是不够的，还有另一个重要指标：

稳定性

意思是元素之间的相对顺序是否保持了不变。

好比说：{5, 2, 2, 1, 0}

这个数组排序完成后这里面的两个 2 的相对顺序没有变，那么这个排序就是一个稳定排序。

那有同窗可能就想，顺序变了又有什么关系呢？

其实，在实际工做中咱们排序的对象不会只是一个数字，而是一个个的对象 (object)，那么先按照对象的一个性质来排序，再按照另外一个性质来排序，那就不但愿原来的那个顺序被改变了。好像有点抽象，咱们举个例子。

好比在股票交易系统里，有买卖双方的报价，那是如何匹配的呢？

• 先按照价格排序；
• 在相等的价格中，按照出价的时间顺序来排序。

那么通常来讲系统会维持一个按时间排序的价格序列，那么此时只须要用一个具备稳定性的排序算法，再按照价格大小来排序就行了。由于稳定性的排序算法能够保持大小相同的两个对象仍维持着原来的时间顺序。

那么插入排序是不是稳定性的排序呢？

答案是确定的。由于在咱们插入新元素的时候是从后往前检查，并非像打牌的时候随便插一个位置不能保证相对顺序。

你们能够看下下面的动画 就很是清楚了～

优化

插入排序实际上是有很大的优化空间的，你能够搜一下“希尔排序”。

在刚开始学习的时候，深度当然重要，但由于广度不够，若是学的太深可能会很痛苦，一个知识点就无穷无尽的延展，这并非一个高效的学习方式。

时间有限时还要作好深度和广度的平衡：

• 在经常使用常考的知识点上多花时间精力，追求深度；
• 在一些拓展性的知识点上点到为止，先知道有这么回事就行。

保持 open minded 的心态，后期就会有质的提升。

选择排序

选择排序也是利用了“挡板法”这个经典思想。

挡板左边是已排序区间，右边是未排序区间，那么每次的“选择”是去找右边未排序区间的最小值，找到以后和挡板后面的第一个值换一下，而后再把挡板往右移动一位，保证排好序的这些元素在挡板的左边。

好比以前的例子：{5, 2, 0, 1}

咱们用一个挡板来分隔数组是否排好序，
用指针 j 来寻找未排序区间的最小值；

第一轮 j 最初指向 5，而后遍历整个未排序区间，最终指向 0，那么 0 就和挡板后的第一个元素换一下，也就是和 5 交换一下位置，挡板向右移动一位，结束第一轮。

第二轮，j 从挡板后的2开始遍历，最终指向1，而后1和挡板后的第一个元素 2 换一下，挡板向右移动一位，结束第二轮。

第三轮，j 从2开始遍历，最终指向2，而后和2本身换一下，挡板向右移动一位，结束第三轮。

还剩一个元素，不用遍历了，就结束了。

选择排序与以前的插入排序对比来看，要注意两点：

1. 挡板必须从 0 开始，而不能从 1 开始。虽然在这两种算法中，挡板的物理意义都是分隔已排序和未排序区间，可是它们的已排序区间里放的元素的意义不一样：

• 选择排序是只能把当前的最小值放进来，而不能放其余的；
• 插入排序的第一个元素能够为任意值。

因此选择排序的挡板左边最开始不能有任何元素。

1. 在外层循环时，

• 选择排序的最后一轮能够省略，由于只剩下最大的那个元素了；

• 插入排序的最后一轮不可省略，由于它的位置还没定呢。

  class Solution {
    public void selectionSort(int[] input) {
      if(input == null || input.length <= 1) {
        return;
      } 
      for(int i = 0; i < input.length - 1; i++) {
        int minValueIndex = i;
        for(int j = i + 1; j < input.length; j++) {
          if(input[j] < input[minValueIndex]) {
            minValueIndex = j;
          }
        }
        swap(input, minValueIndex, i);
      }
    }
    private void swap(int[] input, int x, int y) {
      int tmp = input[x];
      input[x] = input[y];
      input[y] = tmp;
    }
  }

时间复杂度

最内层的 if 语句每执行一次是 O(1) ，那么要执行多少次呢？

• 当 i = 0 时，是 n-1 次；
• 当 i = 1 时，是 n-2 次；
• ...
• 最后是 1 次；

因此加起来，总共是：
(n-1) + (n-2) + … + 1 = n*(n-1) / 2 = O(n^2)

是这样算出来的，而不是一拍脑壳说两层循环就是 O(n^2).

空间复杂度

这个很简单，最多的状况是 call swap() 的时候，而后 call stack 上每一层就用了几个有限的变量，因此是 O(1)。

那天然也是原地排序算法了。

稳定性

这个答案是否认的，选择排序并无稳定性。

由于交换的过程破坏了原有的相对顺序，好比: {5, 5, 2, 1, 0} 这个例子，第一次交换是 0 和 第一个 5 交换，因而第一个 5 跑到了数组的最后一位，且再也无翻身之地，因此第一个 5 第二个 5 的相对顺序就已经打乱了。

这个问题在石头哥的那篇谷歌面经文章里有被考到哦，若是尚未看过这篇面经文章的，在「码农田小齐」公众号里回复「谷歌」二字，就能够看到了。

优化

选择排序的其中一步是选出每一轮的最小值，那么这一步若是使用 heapify() 来优化，就能够从 O(n) 优化到 O(logn)，这其实就变成了 heapSort.