数据结构与算法之美-排序（笔记5）

排序非常重要，排序算法太多了，有很多可能连名字都没听说过，比如猴子排序、睡眠排序、面条排序等。我只讲众多排序算法中最经典的、最常用的：冒泡排序、插入排序、选择排序、归并排序、快速排序、计数排序、基数排序、桶排序。我按照时间复杂度把它们分成了三类

如何分析一个“排序算法”

学习排序算法，我们除了学习它的算法原理、代码实现之外，更重要的是要学会如何评价、分析一个排序算法那分析一个排序算法，要从哪几个方面入手呢？
排序算法的执行效率
对于排序算法执行效率的分析，我们一般会从这几个方面来衡量
1.最好情况、最环情况、平均情况时间复杂度
除此之外你还要说出最好、最坏时间复杂度对应的要排序的原始数据是什么样的。
对于要排序的数据，有的接近有序，有的完全无序。有序度不同的数据，对于排序的执行时间肯定是有影响的，我们要知道排序算法在不同数据下的性能表现。
2.时间复杂度的系数、常数、低阶
我们知道，时间复杂度反应的是数据规模n很大的时候的一个增长超势，所以它表示的时候会忽略系数、常数低阶。但是实际的软件开发中，我们排序的可能是10个、100个、1000个这样规模很小的数据，所以，在对同一阶时间复杂度的排序算法性能对比的时候，我们就要把系数、常数、低阶也考进来。
3.比较次数和交换（或移动）次数
基于比较的排序算法的执行过程，会涉及两种操作，一种是元素比较大小，另一种是元素交换或移动。所以，如果我们在分析排序算法的执行效率的时候，应该把比较次数和交换（或移动）次数也考虑进去。

排序算法的内存消耗

算法的内存消耗可以通过空间复杂度来衡量。不过，针对排序算法的空间复杂度，我们还引入了一个新的概念，原地排序（Sortedinplace）。原地排序算法，就是特指空间复杂度是0（1）的排序算法。
排序算法的稳定性
针对排序算法，我们还有一个重要的度量指标，稳定性。这个概念是说，如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间原有的先后顺序不变。
我通过一个例子来解释一下。比如我们有一组数据2，9，3，4，8，3，按照大小排序之后就是2，3，3，4，8，9。这组数据里有两个3。经过某种排序算法排序之后，如果两个3的前后顺序没有改变，那我们就把这种排序算法叫作稳定的排序算法。很多数据结构和算法课程，在讲排序的时候，都是用整数来举例，但在真正软件开发中，我们要排序的往往不是单纯的整数，而是一组对象，我们需要按照对象的某个key来排序，比如说，我们现在要给电商交易系统中的“订单”排序。订单有两个属性，一个是下单时间，另一个是订单金额。如果我们现在有10万条订单数据，我们希望按照金额从小到大对订单数据排序。对于金额相同的订单，我们希望按照下单时间从早到晚有序。对于这样一个排序需求，我们怎么来做呢？
最先想到的方法是：我们先按照金额对订单数据进行排序，然后，再遍历排序之后的订单数据，对于每个金额相同的小区间再按照下单时间排序。这种排序思路理解起来不难，但是实现起来会很复杂。借助稳定排序算法，这个问题可以非常简洁地解决。解决思路是这样的：我们先按照下单时间给订单排序，注意是按照下单时间，不是金额。排序完成之后，我们用稳定排序算法，按照订单金额重新排序。两遍排序之后，我们得到的订单数据就是按照金额从小到大排序，金额相同的订单按照下单时间从早到晚排序的。

O（n2）

冒泡排序（BubbleSort）

冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求，如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复n次，就完成了n个数据的排序工作。
我用一个例子，带你着下冒泡排序的整个过程。我们要对一组数据4，5，6，3，2，1，从小到到大进行排序第一次冒泡操作的详细过程就是这样

可以看出，经过一次冒泡操作之后，6这个元素已经存储在正确的位置上。要想完成所有数据的排序，我们只要进行6次这样的冒泡操作就行了。

实际上，刚讲的冒泡过程还可以优化。当某次冒泡操作已经没有数据交换时，说明已经达到完全有序，不用再继续执行后续的冒泡操作。我这里还有另外一个例子，这里面给6个元素排序，只需要4次冒泡操作就可以了

代码实现

void bubbleSort(int arr[], int n) {  
    if (n == 0) {  
        return;  
    }  
    for (int i = 0; i < n - 1; i++) {  
        bool flag = false;  
        for (int j = 0; j < n - i - 1; j++) {  
            if (arr[j] > arr[j + 1]) {  
                int temp = arr[j];  
                arr[j] = arr[j + 1];  
                arr[j + 1] = temp;  
                flag = true;  
            }  
        }  
        if (!flag) {  
            break;  
        }  
    }  
}

三个问题

第一冒泡排序是原地排序算法吗？
冒泡的过程只涉及相邻数据的交换，只需要常量级的临时空间，所以它的空间复杂度为0（1），是一个原地排序算法。
第二，冒泡排序是稳定的排序算法吗？
在冒泡排序中，只有交换才可以改变两个元素的前后顺序。为了保证冒泡排序算法的稳定性，当有相邻的两个元素大小相等的时候，我们不做交换，相同大小的数据在排序前后不会改变顺序，所以冒泡排序是稳定的排序算法。
第三，冒泡排序的时间复杂度是多少？
最好情况下，要排序的数据已经是有序的了，我们只需要进行一次冒泡操作，就可以结束了，所以最好情况时间复杂度是O（n）。而最坏的情况是，要排序的数据刚好是倒序排列的，我们需要进行n次冒泡操作，所以最坏情况时间复杂度为O（n2）

平均时间复杂度就是加权平均期望时间复杂度，分析的时候要结合概率论的知识。对于包含n个数据的数组，这n个数据就有n！种排列方式。不同的排列方式，冒泡排序执行的时间肯定是不同的比如我们前面举的那两个例子，其中一个要进行6次冒泡，而另一个只需要4次。如果用概率论方法定量分析平均时间复杂度，涉及的数学推理和计算就会很复杂。我这里还有一种思路，通过“有序度”和“逆序度”这两个概念来进行分析。有序度是数组中具有有序关系的元素对的个数。有序元素对用数学表达式表示就是这样：

同理，对于一个倒序排列的数组，比如6，5，4，3，2，1，有序度是0；对于一个完全有序的数组，比如1,2，3，4，5，6，有序度就是n*（n-1)/2，也就是15。我们把这种完全有序的数组的有序度叫作满有序度。
逆序度的定义正好跟有序度相反（默认从小到大为有序），我想你应该已经想到了。关于逆序度，我就不举例子讲了。
关于这三个概念，我们还可以得到一个公式：逆序度=满有序度-有序度。我们排序的过程就是一种增加有序度减少逆序度的过程，最后达到满有序度，就说明排序完成了。
我还是拿前面举的那个冒泡排序的例子来说明。要排序的数组的初始状态是4，5，6，3，2，1，其中，有序元素对有（4，5）（4，6）（5，6），所以有序度是3。n=6，所以排序完成之后终态的满有序度为n*（n-1）/2=15

冒泡排序包含两个操作原子，比较和交换。每交换一次，有序度就加1。不管算法怎么改进，交换次数总是确定的，即为逆序度，也就是n*（n-1）/2-初始有序度。此例中就是15-3=12，要进行12次交换操作。
对于包含n个数据的数组进行冒泡排序，平均交换次数是多少呢？我们可以取个中间值n（n-1）/4，来表示初始有序度既不是很高也不是很低的平均情况。
换句话说，平均情况下，需要n*（n-1）/4次交换操作，比较操作肯定要比交换操作多，而复杂度的上限是O（n2）所以平均情况下的时间复杂度就是O（n2）。
这个平均时间复杂度推导过程其实并不严格，但是很多时候很实用，毕竟概率论的定量分析太复杂，不太好用。

插入排序（InsertionSort）

我们先来看一个问题。一个有序的数组，我们往里面添加一个新的数据后，如何继续保持数据有序呢？很简单我们只要遍历数组，找到数据应该插入的位置将其插入即可

这是一个动态排序的过程，即动态地往有序集合中添加数据，我们可以通过这种方法保持集合中的数据一直有序。而对于一组静态数据，我们也可以借鉴上面讲的插入方法，来进行排序，于是就有了插入排序算法。
那插入排序具体是如何借助上面的思想来实现排序的呢？
首先，我们将数组中的数据分为两个区间，已排序区间和未排序区间。初始已排序区间只有一个元素，就是数组的第一个元素。插入算法的核心思想是取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入并保证已排序区间数据一直有序。重复这个过程，直到未排序区间中元素为空，算法结束。
如图所示，要排序的数据是4，5，6，1，3，2，其中左侧为已排序区间，右侧是未排序区间

插入排序也包含两种操作，一种是元素的比较，一种是元素的移动。当我们需要将一个数据a插入到已排序区间时，需要拿a与已排序区间的元素依次比较大小，找到合适的插入位置。找到插入点之后，我们还需要将插入点之后的元素顺序往后移动一位，这样才能腾出位置给元素a插入。
对于不同的查找插入点方法（从头到尾、从尾到头），元素的比较次数是有区别的。但对于一个给定的初始序列，移动操作的次数总是固定的，就等于逆序度。
为什么说移动次数就等于逆序度呢？我拿刚才的例子画了一个图表，你一看就明白了。满有序度是n*（n-1）/2=15，初始序列的有序度是5，所以逆序度是10。插入排序中，数据移动的个数总和也等于10=3+3+4。

代码实现

//O(n^2)
//从无序数组中每次拿一个出来进行排序至全部排完
void insert_sort(int a[],int n) {
    int i,j;
    for(i=1; i<n; i++) { //循环从第2个元素开始
        if(a[i]<a[i-1]) {  
            int temp=a[i];  
            for(j=i-1; j>=0 && a[j]>temp; j--) {   //j=0,a[0]>a[1]
               a[j+1]=a[j];
            }
            a[j+1]=temp;
        }
    }
}

三个问题

第一，插入排序是原地排序算法吗？
插入排序算法的运行并不需要额外的存储空间，所以空间复杂度是（1），这是一个原地排序算法。
第二，插入排序是稳定的排序算法吗？
在插入排序中，对于值相同的元素，我们可以选择将后面出现的元素，插入到前面出现元素的后面，这样就可以保持原有的前后顺序不变，所以插入排序是稳定的排序算法。
第三，插入排序的时间复杂度是多少？
如果要排序的数据已经是有序的，我们并不需要搬移任何数据。如果我们从尾到头在有序数据组里面查找插入位置，每次只需要比较一个数据就能确定插入的位置。所以这种情况下，最好是时间复杂度为O（n）。注意，这里是从尾到头遍历已经有序的数据。
如果数组是倒序的，每次插入都相当于在数组的第一个位置插入新的数据，所以需要移动大量的数据，所以最坏情况时间复杂度为O（n2）。
还记得我们在数组中插入一个数据的平均时间复杂度是多少吗？没错，是0(n）。所以，对于插入排序来说，每次插入操作都相当于在数组中插入一个数据，循环执行n次插入操作，所以平均时间复杂度为O（n2)

选择排序（SelectionSort）

选择排序算法的实现思路有点类似插入排序，也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。

代码实现

//O(n^2)
void select_sort(int a[],int n){
    int temp;
    for(int i=0;i<n-1;i++){
        temp=i;      //利用一个中间变量temp来记录需要交换元素的位置
        for(int j=i+1;j<n;j++){
            if(a[temp]>a[j]){   //选出待排数据中的最小值
                temp=j;  
            }
        }
        swap(a[i],a[temp]); //交换函数
    }
}

三个问题

首先，选择排序空间复杂度为O（1），是一种原地排序算法。选择排序的最好情况时间复杂度、最坏情况和平均情况时间复杂度都为O（n2）。
那选择排序是稳定的排序算法吗？
答案是否定的，选择排序是一种不稳定的排序算法。从我前面画的那张图中，你可以看出来，选择排序每次都要找剩余未排序元素中的最小值，并和前面的元素交换位置，这样破坏了稳定性。
比如5，8，5，2，9这样一组数据，使用选择排序算法来排序的话，第一次找到最小元素2，与第一个5交换位置，那第一个5和中间的5顺序就变了，所以就不稳定了。正是因此，相对于冒泡排序和插入排序，选择排序就稍微逊色了。

应用

插入排序和冒泡排序的时间复杂度相同，都是0（n2），在实际的软件开发里，为什么我们更倾向于使用插入排序算法而不是冒泡排序算法呢？
我们前面分析冒泡排序和插入排序的时候讲到，冒泡排序不管怎么优化，元素交换的次数是一个固定值，是原始数据的逆序度。插入排序是同样的，不管怎么优化，元素移动的次数也等于原始数据的逆序度。
但是，从代码实现上来看，冒泡排序的数据交换要比插入排序的数据移动要复杂，冒泡排序需要3个赋值操作而插入排序只需要1个。我们把执行一个赋值语句的时间粗略地计为单位时间（unit_time），然后分别用冒泡排序和插入排序对同一个逆序度是K的数组进行排序。用冒泡排序，需要K次交换操作，每次需要3个赋值语句，所以交换操作总耗时就是3*K单位时间。而插入排序中数据移动模作只需要K个单位时间。
这个只是我们非常理论的分析，为了实验，针对上面的冒泡排序和插入排序的Java代码，我写了一个性能对比测试程序，随机生成10000个数组，每个数组中包含200个数据，然后在我的机器上分别用冒泡和插入排序算法来排序，冒泡排序算法大约700ms才能执行完成，而插入排序只需要100ms左右就能搞定！
所以，虽然冒泡排序和插入排序在时间复杂度上是一样的，都是O（n2），但是如果我们希望把性能优化做到极致，那肯定首选插入排序。插入排序的算法思路也有很大的优化空间，我们只是讲了最基础的一种。如果你对插入排序的优化感兴趣，可以自行学习一下希尔排序。

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

课后思考

我们讲过，特定算法是依赖特定的数据结构的。我们今天讲的几种排序算法，都是基于数组实现的。如果数据存储在链表中，这三种排序算法还能工作吗？如果能，那相应的时间、空间复杂度又是多少呢？

O(logn)

归并排序（MergeSort）。

归并排序的核心思想还是简单的。如果要排序一个数组，我们先把数组从中间分成前后两部分，然后对前后两部分分别排序，再将排好序的两部分合并在一起，这样整个数组就都有序了

从我刚才的描述，你有没有感觉到，分治思想跟我们前面讲的递归思想很像。是的，分治算法一般都是用递归来实现的。分治是一种解决问题的处理思想，递归是一种编程技巧，这两者并不冲突。
前面我通过举例让你对归并有了一个感性的认识，又告诉你，归并排序用的是分治思想，可以用递归来实现。我们现在就来看看如何用递归代码来实现归并排序
我在第10节讲的递归代码的编写技巧你还记得吗？写递归代码的技巧就是，分析得出递推公式，然后找到终止条件，最后将递推公式翻译成递归代码。所以，要想写出归并排序的代码，我们先写出归并排序的递推公式

递推公式：
merge_sort(p…r) = merge(merge_sort(p…q), merge_sort(q+1…r))
//下标p到r之间的数组排序，转化为p到q和q+1到r的数组排序
终止条件：
p >= r 不用再继续分解
//q等于p和r的中间位置

当下标从p到q和从q+1到r这两个子数组都排好序之后，我们再将两个有序的子数组合并在一起，这样下标从p到r之间的数据就也排好序了。
有了递推公式，转化成代码就简单多了。为了阅读方便，我这里只给出伪代码，你可以翻译成你熟悉的编程语言。

// 归并排序算法, A是数组，n表示数组大小
merge_sort(A, n) {
  merge_sort_c(A, 0, n-1)
}

// 递归调用函数
merge_sort_c(A, p, r) {
  // 递归终止条件
  if p >= r  then return

  // 取p到r之间的中间位置q
  q = (p+r) / 2
  // 分治递归
  merge_sort_c(A, p, q)
  merge_sort_c(A, q+1, r)
  // 将A[p...q]和A[q+1...r]合并为A[p...r]
  merge(A[p...r], A[p...q], A[q+1...r])
}

c语言代码
void merge_sort(int A[], int n) {
  merge_sort_c(A, 0, n - 1);
}

void merge_sort_c(int A[], int p, int r) {
  if (p >= r) {
    return;
  }
  
  int q = (p + r) / 2;
  merge_sort_c(A, p, q);
  merge_sort_c(A, q + 1, r);
  merge(A, p, q, r);
}

void merge(int A[], int p, int q, int r) {
  int i = p, j = q + 1, k = 0;
  int* tmp = (int*) malloc(sizeof(int) * (r - p + 1));
  
  while (i <= q && j <= r) {
    if (A[i] <= A[j]) {
      tmp[k++] = A[i++];
    } else {
      tmp[k++] = A[j++];
    }
  }
  
  int start = i, end = q;
  if (j <= r) {
    start = j;
    end = r;
  }
  
  while (start <= end) {
    tmp[k++] = A[start++];
  }
  
  for (i = 0; i <= r - p; i++) {
    A[p + i] = tmp[i];
  }
  
  free(tmp);
}

你可能已经发现了，merge(A[p…r],A[p…q]，A[q+1…r])）这个函数的作用就是，将已经有序的A[p…q和A[q+1…合并成一个有序的数组，并且放入A[p…r]。那这个过程具体该如何做呢？
如图所示，我们申请一个临时数组tmp，大小与A[p…r]相同。我们用两个游标i和j，分别指向A[p…q]和A[q+1…r]的第一个元素。比较这两个元素A[i]和A[j]，如果A[i]<=A[j]，我们就把A[i]放入到临时数组tmp，并且i后移一位，否则将A[j]放入到数组tmp，后移一位。
继续上述比较过程，直到其中一个子数组中的所有数据都放入临时数组中，再把另一个数组中的数据依次加入到临时数组的末尾，这个时候，临时数组中存储的就是两个子数组合并之后的结果了。最后再把临时数组tmp中的数据贝到原数组A[p…r]中

我们把merge()函数写成伪代码，就是下面这样：

merge(A[p...r], A[p...q], A[q+1...r]) {
  var i := p，j := q+1，k := 0 // 初始化变量i, j, k
  var tmp := new array[0...r-p] // 申请一个大小跟A[p...r]一样的临时数组
  while i<=q AND j<=r do {
    if A[i] <= A[j] {
      tmp[k++] = A[i++] // i++等于i:=i+1
    } else {
      tmp[k++] = A[j++]
    }
  }
  
  // 判断哪个子数组中有剩余的数据
  var start := i，end := q
  if j<=r then start := j, end:=r
  
  // 将剩余的数据拷贝到临时数组tmp
  while start <= end do {
    tmp[k++] = A[start++]
  }
  
  // 将tmp中的数组拷贝回A[p...r]
  for i:=0 to r-p do {
    A[p+i] = tmp[i]
  }
}

c语言代码
void merge(int A[], int p, int q, int r) {
  int i = p, j = q + 1, k = 0;
  int* tmp = (int*) malloc(sizeof(int) * (r - p + 1));
  
  while (i <= q && j <= r) {
    if (A[i] <= A[j]) {
      tmp[k++] = A[i++];
    } else {
      tmp[k++] = A[j++];
    }
  }
  
  int start = i, end = q;
  if (j <= r) {
    start = j;
    end = r;
  }
  
  while (start <= end) {
    tmp[k++] = A[start++];
  }
  
  for (i = 0; i <= r - p; i++) {
    A[p + i] = tmp[i];
  }
  
  free(tmp);
}

完整可运行代码：

#include <stdio.h>
#include <stdlib.h>

void merge(int A[], int p, int q, int r) {
  int i = p, j = q + 1, k = 0;
  int* tmp = (int*) malloc(sizeof(int) * (r - p + 1));
  
  while (i <= q && j <= r) {
    if (A[i] <= A[j]) {
      tmp[k++] = A[i++];
    } else {
      tmp[k++] = A[j++];
    }
  }
  
  int start = i, end = q;
  if (j <= r) {
    start = j;
    end = r;
  }
  
  while (start <= end) {
    tmp[k++] = A[start++];
  }
  
  for (i = 0; i <= r - p; i++) {
    A[p + i] = tmp[i];
  }
  
  free(tmp);
}

void merge_sort_c(int A[], int p, int r) {
  if (p >= r) {
    return;
  }
  
  int q = (p + r) / 2;
  merge_sort_c(A, p, q);
  merge_sort_c(A, q + 1, r);
  merge(A, p, q, r);
}

void merge_sort(int A[], int n) {
  merge_sort_c(A, 0, n - 1);
}

int main() {
  int A[] = {3, 7, 4, 8, 6, 2, 1, 5};
  int n = sizeof(A) / sizeof(A[0]);
  
  printf("Before sorting:\n");
  for (int i = 0; i < n; i++) {
    printf("%d ", A[i]);
  }
  
  merge_sort(A, n);
  
  printf("\nAfter sorting:\n");
  for (int i = 0; i < n; i++) {
    printf("%d ", A[i]);
  }
  
  return 0;
}

你还记得第7讲讲过的利用哨兵简化编程的处理技巧吗？merge()合并函数如果借助哨兵，代码就会简洁很多。

使用哨兵的merge()代码：(和原来的函数具有相同的效果，虽然使用哨兵会使代码更简洁，但它也需要为每个子数组分配额外的空间来存储哨兵值，并且要注意选择适当的哨兵值，否则可能会影响算法的正确性和效率。)

void merge(int A[], int p, int q, int r) {
  int n1 = q - p + 1;
  int n2 = r - q;
  
  // 创建两个临时数组，用于存放左右子数组以及两个哨兵
  int* L = (int*) malloc(sizeof(int) * (n1 + 1));
  int* R = (int*) malloc(sizeof(int) * (n2 + 1));
  
  for (int i = 0; i < n1; i++) {
    L[i] = A[p + i];
  }
  
  for (int j = 0; j < n2; j++) {
    R[j] = A[q + j + 1];
  }
  
  // 设置左右子数组的哨兵
  L[n1] = INT_MAX;
  R[n2] = INT_MAX;
  
  int i = 0, j = 0;
  for (int k = p; k <= r; k++) {
    if (L[i] <= R[j]) {
      A[k] = L[i++];
    } else {
      A[k] = R[j++];
    }
  }
  
  // 释放临时数组
  free(L);
  free(R);
}

归并排序的性能分析
三个问题
第一，归并排序是稳定的排序算法吗？
合并过程中，如果A[p…q]和A[q+1…r]之间有相同的元素，就先把A[p…q]放入tmp数组，保证了值相同的元素合并前后的先后顺序不变，因此归并排序是稳定的排序算法。
第二，归并排序的时间复杂度是多少？
归并排序涉及递归，时间复杂度的分析稍微有点复杂。我们正好借此机会来学习一下，如何分析递归代码的时间复杂度。
在递归那一节我们讲过，递归的适用场景是，一个问题a可以分解为多个子问题b、c，那求解问题a就可以分解为求解问题b、c。问题b、c解决之后，我们再把b、c的结果合并成a的结果
我们定义求解问题的时间分别为T(a），T(b）和T（c），那我们就可以得到这样的递推关系式：
T（a）=T（b）+T（c）+k
其中K等于将两个子问题b、c的结果合并成问题a的结果所消耗的时间
从刚刚的分析，我们可以得到一个重要的结论：不仅递归求解的问题可以写成递推公式，递归代码的时间复杂度也可以写成递推公式。
套用这个公式，我们来分析一下归并排序的时间复杂度
我们假设对n个元素进行归并排序需要的时间是T（n），那分解成两个子数组排序的时间都是T（n/2）。我们知道merge（）函数合并两个有序子数组的时间复杂度是O（n）。所以，套用前面的公式，归并排序的时间复杂度的计算公式就是：

T(1) = C；   n=1时，只需要常量级的执行时间，所以表示为C。
T(n) = 2*T(n/2) + n； n>1

通过这个公式，如何来求解T（n)呢？还不够直观？那我们再进一步分解一下计算过程

T(n) = 2*T(n/2) + n
     = 2*(2*T(n/4) + n/2) + n = 4*T(n/4) + 2*n
     = 4*(2*T(n/8) + n/4) + 2*n = 8*T(n/8) + 3*n
     = 8*(2*T(n/16) + n/8) + 3*n = 16*T(n/16) + 4*n
     ......
     = 2^k * T(n/2^k) + k * n
     ......

我们可以得到T（n）=2^kT（n/2k）+kn。当T（n/2^{k）=T（1）时，也就是n/2}k=1我们得到k=log2n。我们将k值代入上面的公式，得到T(n）=Cn+nlog2n。如果我们用大0标记法来表示的话T(n）就等于O（nlogn）。所以归并排序的时间复杂度是O（nlogn）
从我们的原理分析和伪代码可以看出，归并排序的执行效率与要排序的原始数组的有序程度无关，所以其时间复杂度是非常稳定的，不管是最好情况、最坏情况，还是平均情况，时间复杂度都是O（nlogn）。

第三，归并排序的空间复杂度是多少？
归并排序的时间复杂度任何情况下都是O（nlogn），看起来非常优秀。（待会儿你会发现，即便是快速排序，最坏情况下，时间复杂度也是O（n）。但是，归并排序并没有像快排那样，应用广泛。因为它有个致命的“弱点”，那就是归并排序不是原地排序算法,这是因为归并排序的合并函数，在合并两个有序数组为一个有序数组时，需要借助额外的存储空间。这一点你应该很容易理解。那我现在问你，归并排序的空间复杂度到底是多少呢？是O(n），还是O（nlogn），应该如何分析呢？
如果我们继续按照分析递归时间复杂度的万法，通过递推公式来求解，那整个归并过程需要的空间复杂度就是O（nlogn）。不过，类似分析时间复杂度那样来分析空间复杂度，这个思路对吗？
实际上，递归代码的空间复杂度并不能像时间复杂度那样累加。刚刚我们忘记了最重要的一点，那就是，尽管每次合并操作都需要申请额外的内存空间，但在合并完成之后，临时开辟的内存空间就被释放掉了。在任意时刻CPU只会有一个函数在执行，也就只会有一个临时的内存空间在使用。临时内存空间最大也不会超过n个数据的大小，所以空间复杂度是O（n）

快速排序（Quicksort）

我们习惯性把它简称为“快排”。快排利用的也是分治思想。乍看起来，它有点像归并排序，但是思路其实完全不一样。。
快排的思想是这样的：如果要排序数组中下标从p到r之间的一组数据，我们选择p到r之间的任意一个数据作为pivot（分区点）。
我们遍历p到r之间的数据，将小于pivot的放到左边，将大于pivot的放到右边，将pivot放到中间。经过这一骤之后，数组p到r之间的数据就被分成了三个部分，前面p到q-1之间都是小于pivot的，中间是pivot，后面的q+1到r之间是大于pivot的。

根据分治、递归的处理思想，我们可以用递归排序下标从p到q-1之间的数据和下标从q+1到r之间的数据，直到区间缩小为1，就说明所有的数据都有序了。

递推公式：
quick_sort(p…r) = quick_sort(p…q-1) + quick_sort(q+1… r)
终止条件：
p >= r

我将递推公式转化成递归代码。跟归并排序一样，我还是用伪代码来实现，你可以翻译成你熟悉的任何语言

// 快速排序，A是数组，n表示数组的大小
quick_sort(A, n) {
  quick_sort_c(A, 0, n-1)
}
// 快速排序递归函数，p,r为下标
quick_sort_c(A, p, r) {
  if p >= r then return
  
  q = partition(A, p, r) // 获取分区点
  quick_sort_c(A, p, q-1)
  quick_sort_c(A, q+1, r)
}

// 快速排序，A是数组，n表示数组的大小
void quick_sort(int A[], int n) {
    quick_sort_c(A, 0, n-1);
}

// 快速排序递归函数，p,r为下标
void quick_sort_c(int A[], int p, int r) {
    if (p >= r) return;

    int q = partition(A, p, r); // 获取分区点
    quick_sort_c(A, p, q-1);
    quick_sort_c(A, q+1, r);
}

归并排序中有一个merge()合并函数，我们这里有一个partition()分区函数。分区函数实际上我们前面已经讲过了，就是随机选择一个元素作为pivot（一般情况下，可以选择p到r区间的最后一个元素），然后对A(p…r)分区，函数返回pivot的下标。
如果我们不考虑空间消耗的话，分区函数可以写得非常简单。我们申请两个临时数组X和Y，遍历A[p…r]，将小于pivot的元素都贝到临时数组X，将大于pivot的元素都拷贝到临时数组Y，最后再将数组X和数组Y中数据顺序贝到A[p…r]

但是，如果按照这种思路实现的话，partition函数就需要很多额外的内存空间，所以快排就不是原地排序算法了。如果我们希望快排是原地排序算法，那它的空间复杂度得是O（1），那partition分区函数就不能占用太多额外的内存空间，我们就需要在A[p…r]的原地完成分区操作。
原地分区函数的实现思路非常巧妙，我写成了伪代码，我们一起来看一下。

partition(A, p, r) {
  pivot := A[r]
  i := p
  for j := p to r-1 do {
    if A[j] < pivot {
      swap A[i] with A[j]
      i := i+1
    }
  }
  swap A[i] with A[r]
  return i
  }

int partition(int A[], int p, int r) {
    int pivot = A[r];
    int i = p;
    for (int j = p; j < r; j++) {
        if (A[j] < pivot) {
            // swap A[i] with A[j]
            int temp = A[i];
            A[i] = A[j];
            A[j] = temp;
            i++;
        }
    }
    // swap A[i] with A[r]
    int temp = A[i];
    A[i] = A[r];
    A[r] = temp;
    return i;
}

这里的处理有点类似选择排序。我们通过游标i把A[p…r-1]分成两部分。A[p…i-1]的元素都是小于pivot的，我们暂且叫它“已处理区间”，A[i…r-1]是“未处理区间”。我们每次都从未处理的区间A[i…r-1]中取一个元素A[j]，与pivot对比，如果小于pivot，则将其加入到已处理区间的尾部，也就是A[i]的位置。
数组的插入操作还记得吗？在数组某个位置插入元素，需要搬移数据，非常耗时。当时我们也讲了一种处理技巧，就是交换，在0（1)的时间复杂度内完成插入操作。这里我们也借助这个思想，只需要将A[i]与A[j]交换，就可以在O（1）时间复杂度内将A[j]放到下标为i的位置。

因为分区的过程涉及交换操作，如果数组中有两个相同的元素，比如序列6，8，7，6，3，5，9，4，在经过第一次分区操作之后，两个6的相对先后顺序就会改变。所以，快速排序并不是一个稳定的排序算法。

到此，快速排序的原理你应该也掌握了。现在，我再来看另外一个问题：快排和归并用的都是分治思想，递推公式和递归代码也非常相似，那它们的区别在哪里呢？

可以发现，归并排序的处理过程是由下到上的，先处理子问题，然后再合并。而快排正好相反，它的处理过程是由上到下的，先分区，然后再处理子问题。归并排序虽然是稳定的、时间复杂度为O（nlogn）的排序算法，但是它是非原地排序算法。我们前面讲过，归并之所以是非原地排序算法，主要原因是合并函数无法在原地执行。快速排序通过设计巧妙的原地分区函数，可以实现原地排序，解决了归并排序占用太多内存的问题。

代码实现：

#include <stdio.h>
#include<stdlib.h>

void quick_sort_c(int A[], int p, int r);
int partition(int A[], int p, int r);

void quick_sort(int A[], int n) {
    quick_sort_c(A, 0, n-1);
}

void quick_sort_c(int A[], int p, int r) {
    if (p >= r) return;

    int q = partition(A, p, r); // 获取分区点
    quick_sort_c(A, p, q-1);
    quick_sort_c(A, q+1, r);
}

int partition(int A[], int p, int r) {
    int pivot = A[r];
    int i = p;
    for (int j = p; j < r; j++) {
        if (A[j] < pivot) {
            // swap A[i] with A[j]
            int temp = A[i];
            A[i] = A[j];
            A[j] = temp;
            i++;
        }
    }
    // swap A[i] with A[r]
    int temp = A[i];
    A[i] = A[r];
    A[r] = temp;
    return i;
}

int main() {
    int A[] = {5, 2, 9, 3, 7, 4, 6, 8, 1};
    int n = sizeof(A) / sizeof(A[0]);

    printf("Before sorting:\n");
    for (int i = 0; i < n; i++) {
        printf("%d ", A[i]);
    }

    quick_sort(A, n);

    printf("\nAfter sorting:\n");
    for (int i = 0; i < n; i++) {
        printf("%d ", A[i]);
    }
    system("pause");
    return 0;
}

快速排序的性能分析
现在，我们来分析一下快速排序的性能。我在讲解快排的实现原理的时候，已经分析了稳定性和空间复杂度。快排是一种原地、不稳定的排序算法。现在，我们集中精力来看快排的时间复杂度
快排也是用递归来实现的。对于递归代码的时间复杂度，我前面总结的公式，这里也还是适用的。如果每次分区操作，都能正好把数组分成大小接近相等的两个小区间，那快排的时间复杂度递推求解公式跟归并是相同的。所以，快排的时间复杂度也是O（nlogn）。
但是，公式成立的前提是每次分区操作，我们选择的pivot都很合适，正好能将大区间对等地一分为二。但实际上这种情况是很难实现的。
我举一个比较极端的例子。如果数组中的数据原来已经是有序的了，比如1，3，5，6，8。如果我们每次选择最后一个元素作为pivot，那每次分区得到的两个区间都是不均等的。我们需要进行大约n次分区操作，才能完成快排的整个过程。每次分区我们平均要扫描大约n/2个元素，这种情况下，快排的时间复杂度就从（nlogn）退化成了o（n²）。
我们刚刚讲了两个极端情况下的时间复杂度，一个是分区极其均衡，一个是分区极其不均衡。它们分别对应快排的最好情况时间复杂度和最坏情况时间复杂度。那快排的平均情况时间复杂度是多少呢？
我们假设每次分区操作都将区间分成大小为9:1的两个小区间。我们继续套用递归时间复杂度的递推公式，就会 变成这样：
T(1）=C； n=1时，只需要常量级的执行时间，所以表示为C。T（n）=（n/10）+T（9/10）+n；n>1
这个公式的递推求解的过程非常复杂，虽然可以求解，但我不推荐用这种方法。实际上，递归的时间复杂度的求解方法除了递推公式之外，还有递归树，在树那一节我再讲，这里暂时不说。我这里直接给你结论：T（n）在大部分情况下的时间复杂度都可以做到O（nlogn），只有在极端情况下，才会退化到O（n2）。而且，我们也有很多方法将这个概率降到很低，如何来做？我们后面章节再讲。

应用

如何在0（n）的时间复杂度内查找一个无序数组中的第K大元素？
快排核心思想就是分治和分区，我们可以利用分区的思想，来解答：O（n）时间复杂度内求无序数组中的第K大元素。比如，4，2，5，12，3这样一组数据，第3大元素就是4。
我们选择数组区间A[0…n-1]的最后一个元素A[n-1]作为pivot，对数组A[0…n-1]原地分区，这样数组就分成了三部分，A[0…p-1]、A[p]、A[p+1…n-1]。
如果p+1=K，那AIp]就是要求解的元素；如果K>p+1，说明第K大元素出现在A[p+1…n-1]区间，我们再按照上面的思路递归地在A[p+1…n-1]这个区间内查找。同理，如果K<p+1，那我们就在A[0…p-1]区间查找。

我们再来看，为什么上述解决思路的时间复杂度是0（n）？
第一次分区查找，我们需要对大小为n的数组执行分区操作，需要遍历n个元素。第二次分区查找，我们只需要对大小为n/2的数组执行分区操作，需要遍历n/2个元素。依次类推，分区遍历元素的个数分别为、n/2、n/4、n/8、n/16…直到区间缩小为1。
如果我们把每次分区遍历的元素个数加起来，就是：n+n/2+n/4+n/8+…+1。这是一个等比数列求和，最后的和等于2n-1。所以，上述解决思路的时间复杂度就为O（n）。
你可能会说，我有个很笨的办法，每次取数组中的最小值，将其移动到数组的最前面，然后在剩下的数组中继续找最小值，以此类推，执行K次，找到的数据不就是第K大元素了吗？
不过，时间复杂度就并不是0（n）了，而是（k*n）。你可能会说，时间复杂度前面的系数不是可以忽略吗？0（Kn）不就等于O（n）吗？
这个可不能这么简单地划等号。当K是比较小的常量时，比如1、2，那最好时间复杂度确实是O（n）；但当K等于n/2或者n时，这种最坏情况下的时间复杂度就是0（n2）了。
内容小结
归并排序算法是一种在任何情况下时间复杂度都比较稳定的排序算法，这也使它存在致命的缺点，即归并排序不是原地排序算法，空间复杂度比较高，是（n）。正因为此，它也没有快排应用广泛。
快速排序算法虽然最坏情况下的时间复杂度是O（n2），但是平均情况下时间复杂度都是O（nlogn)。不仅如此，快速排序算法时间复杂度退化到O（n2）的概率非常小，我们可以通过合理地选择pivot来避免这种情况。

课后思考

现在你有10个接口访问日志文件，每个日志文件大小约300MB，每个文件里的日志都是按照时间从小到大排序的。你希望将这10个较小的日志文件，合并为1个日志文件，合并之后的日志仍然按照时间截从小到大排列如果处理上述排序任务的机器内存只有1GB，你有什么好的解决思路，能“快速”地将这10个日志文件合并吗？

每次从各个文件中取一条数据，在内存中根据数据时间戳构建一个最小堆，然后每次把最小值给写入新文件，同时将最小值来自的那个文件再出来一个数据，加入到最小堆中。这个空间复杂度为常数，但没能很好利用1g内存，而且磁盘单个读取比较慢，所以考虑每次读取一批数据，没了再从磁盘中取，时间复杂度还是一样O(n)。
先构建十条io流，分别指向十个文件，每条io流读取对应文件的第一条数据，然后比较时间戳，选择出时间戳最小的那条数据，将其写入一个新的文件，然后指向该时间戳的io流读取下一行数据，然后继续刚才的操作，比较选出最小的时间戳数据，写入新文件，io流读取下一行数据，以此类推，完成文件的合并， 这种处理方式，日志文件有n个数据就要比较n次，每次比较选出一条数据来写入，时间复杂度是O（n），空间复杂度是O（1）,几乎不占用内存

O（n）

桶排序、计数排序、基数排序。因为这些排序算法的时间复杂度是线性的，所以我们把这类排序算法叫作线性排序（Linearsort）。之所以能做到线性的时间复杂度，主要原因是，这三个算法是非基于比较的排序算法，都不涉及元素之间的比较操作。
这几种排序算法理解起来都不难，时间、空间复杂度分析起来也很简单，但是对要排序的数据要求很刻，所以我们今天学习重点的是掌握这些排序算法的适用场景。
我先给你出一道思考题：如何根据年龄给100万用户排序？你可能会说，我用上一节课讲的归并、快排就可以搞定啊！是的，它们也可以完成功能，但是时间复杂度最低也是O（nlogn）。有没有更快的排序方法呢？让我们一起进入今天的内容！

桶排序（Bucketsort）

首先，我们来看桶排序。桶排序，顾名思义，会用到“桶”，核心思想是将要排序的数据分到几个有序的桶里每个桶里的数据再单独进行排序。桶内排完序之后，再把每个桶里的数据按照顺序依次取出，组成的序列就是有序的了。

如果要排序的数据有n个，均匀地划分到m个桶内，每个桶里就有k=n/m个元素。每个桶内部使用快速排序，时间复杂度为O（k*logk）。m个桶排序的时间复杂度就是O（m*k*logk），因为k=n/m，所以整个桶排序的时间复杂度就是O（n*log（n/m））。当桶的个数m接近数据个数n时，log（n/m）就是一个非常小的常量，这个时候桶排序的时间复杂度接近O（n）桶排序看起来很优秀，那它是不是可以替代我们之前讲的排序算法呢？
答案当然是否定的。为了让你轻松理解桶排序的核心思想，我刚才做了很多假设。实际上，桶排序对要排序数据的要求是非常苛刻的。
首先，要排序的数据需要很容易就能划分成m个桶，并且，桶与桶之间有着天然的大小顺序。这样每个桶内的数据都排序完之后，桶与桶之间的数据不需要再进行排序。
其次，数据在各个桶之间的分布是比较均匀的。如果数据经过桶的划分之后，有些桶里的数据非常多，有些非常少，很不平均，那桶内数据排序的时间复杂度就不是常量级了。在极端情况下，如果数据都被划分到一个桶里，那就退化为O（nlogn）的排序算法了
桶排序比较适合用在外部排序中。所谓的外部排序就是数据存储在外部磁盘中，数据量比较大，内存有限，无法将数据全部加载到内存中
比如说我们有10GB的订单数据，我们希望按订单金额（假设金额都是正整数）进行排序，但是我们的内存有限，只有几百MB，没办法一次性把10GB的数据都加载到内存中。这个时候该怎么办呢？
我们可以先扫描一遍文件，看订单金额所处的数据范围。假设经过扫描之后我们得到，订单金额最小是1元，最大是10万元。我们将所有订单根据金额划分到100个桶里，第一个桶我们存储金额在1元到1000元之内的订单，第二桶存储金额在1001元到2000元之内的订单，以此类推。每一个桶对应一个文件，并且按照金额范围的大小顺序编号命名（00，01，02…99）。
理想的情况下，如果订单金额在1到10万之间均匀分布，那订单会被均匀划分到100个文件中，每个小文件中存储大约100MB的订单数据，我们就可以将这100个小文件依次放到内存中，用快排来排序。等所有文件都排好序之后，我们只需要按照文件编号，从小到大依次读取每个小文件中的订单数据，并将其写入到一个文件中，那这个文件中存储的就是按照金额从小到大排序的订单数据了。
不过，你可能也发现了，订单按照金额在1元到10万元之间并不一定是均匀分布的，所以10GB订单数据是无法均匀地被划分到100个文件中的。有可能某个金额区间的数据特别多，划分之后对应的文件就会很大，没法一次性读入内存。这又该怎么办呢？
针对这些划分之后还是比较大的文件，我们可以继续划分，比如，订单金额在1元到1000元之间的比较多，我们就将这个区间继续划分为10个小区间，1元到100元，101元到200元，201元到300元…901元到1000元。如果划分之后，101元到200元之间的订单还是太多，无法一次性读入内存，那就继续再划分，直到所有的文件都能读入内存为止。

计数排序（Countingsort）

我个人觉得，计数排序其实是桶排序的一种特殊情况。当要排序的n个数据，所处的范围并不大的时候，比如最大值是k，我们就可以把数据划分成k个桶。每个桶内的数据值都是相同的，省掉了桶内排序的时间。
我们都经历过高考，高考查分数系统你还记得吗？我们查分数的时候，系统会显示我们的成绩以及所在省的排名。如果你所在的省有50万考生，如何通过成绩快速排序得出名次呢？
考生的满分是900分，最小是0分，这个数据的范围很小，所以我们可以分成901个桶，对应分数从0分到900分。根据考生的成绩，我们将这50万考生划分到这901个桶里。桶内的数据都是分数相同的考生，所以并不需要再进行排序。我们只需要依次扫描每个桶，将桶内的考生依次输出到一个数组中，就实现了50万考生的排序。因为只涉及扫描遍历操作，所以时间复杂度是O（n）
计数排序的算法思想就是这么简单，跟桶排序非常类似，只是桶的大小粒度不一样。不过，为什么这个排序算法叫“计数”排序呢？“计数”的含义来自哪里呢？
想弄明白这个问题，我们就要来看计数排序算法的实现方法。我还拿考生那个例子来解释。为了方便说明，我对数据规模做了简化。假设只有8个考生，分数在0到5分之间。这8个考生的成绩我们放在一个数组A[8]中，它们分别是：2，5，3，0，2，3，0，3。
考生的成绩从0到5分，我们使用大小为6的数组C[6]表示桶，其中下标对应分数。不过，C[6]内存储的并不是考生，而是对应的考生个数。像我刚刚举的那个例子，我们只需要遍历一遍考生分数，就可以得到C[6]的值

从图中可以出，分数为3分的考生有3个，小于3分的考生有4个，所以，成绩为3分的考生在排序之后的有序数组R[8]中，会保存下标4，5，6的位置

那我们如何快速计算出，每个分数的考生在有序数组中对应的存储位置呢？这个处理方法非常巧妙，很不容易想到。
思路是这样的：我们对C[6]数组顺序求和，C[6]存储的数据就变成了下面这样子。C[k]里存储小于等于分数k的考生个数。

有了前面的数据准备之后，现在我就要讲计数排序中最复杂、最难理解的一部分了。我们从后到前依次扫描数组A。比如，当扫描到3时，我们可以从数组C中取出下标为3的值7，也就是说，到目前为止，包括自己在内，分数小于等于3的考生有7个，也就是说3是数组R中的第7个元素（也就是数组R中下标为6的位置）。当3放入到数组R中后，小于等于3的元素就只剩下了6个了，所以相应的C[3]要减1，变成6。
以此类推，当我们扫描到第2个分数为3的考生的时候，就会把它放入数组R中的第6个元素的位置（也就是下标为5的位置）。当我们扫描完整个数组A后，数组R内的数据就是按照分数从小到大有序排列的了。

上面的过程有点复杂，我写成了代码，你可以对照着看下。

 // 计数排序，a是数组，n是数组大小。假设数组中存储的都是非负整数。
  public static void countingSort(int[] a) {
	int n = a.length;
    if (n <= 1) return;
 
    // 查找数组中数据的范围
    int max = a[0];
    for (int i = 1; i < n; ++i) {
      if (max < a[i]) {
        max = a[i];
      }
    }
 
    // 申请一个计数数组c，下标大小[0,max]
    int[] c = new int[max + 1];
    for (int i = 0; i < max + 1; ++i) {
      c[i] = 0;
    }
 
    // 计算每个元素的个数，放入c中
    for (int i = 0; i < n; ++i) {
      c[a[i]]++;
    }
 
    // 依次累加
    for (int i = 1; i < max + 1; ++i) {
      c[i] = c[i-1] + c[i];
    }
 
    // 临时数组r，存储排序之后的结果
    int[] r = new int[n];
    // 计算排序的关键步骤了，有点难理解
    for (int i = n - 1; i >= 0; --i) {
      int index = c[a[i]]-1;
      r[index] = a[i];
      c[a[i]]--;
    }
 
    // 将结果拷贝会a数组
    for (int i = 0; i < n; ++i) {
      a[i] = r[i];
    }
  }

这种利用另外一个数组来计数的实现方式是不是很巧妙呢？这也是为什么这种排序算法叫计数排序的原因。不过，你千万不要死记硬背上面的排序过程，重要的是理解和会用。
我总结一下，计数排序只能用在数据范围不大的场景中，如果数据范国k比要排序的数据n大很多，就不适合用计数排序了。而且，计数排序只能给非负整数排序，如果要排序的数据是其他类型的，要将其在不改变相对大小的情况下，转化为非负整数。
比如，还是拿考生这个例子。如果考生成绩精确到小数后一位，我们就需要将所有的分数都先乘以10，转化成整数，然后再放到9010个桶内。再比如，如果要排序的数据中有负数，数据的范围是[-1000，1000]，那我们就需要先对每个数据都加1000，转化成非负整数

基数排序（Radixsort）

假设我们有10万个手机号码，希望将这10万个手机号码从小到大排序，你有什么比较快速的排序方法呢？
我们之前讲的快排，时间复杂度可以做到O（nlogn），还有更高效的排序算法吗？桶排序、计数排序能派上用场吗？手机号码有11位，范围太大，显然不适合用这两种排序算法。针对这个排序问题，有没有时间复杂度是O（n）的算法呢？现在我就来介绍一种新的排序算法，基数排序。
刚刚这个问题里有这样的规律：假设要比较两个手机号码a，b的大小，如果在前面几位中，a手机号码已经比b手机号码大了，那后面的几位就不用着了。
借助稳定排序算法，这里有一个巧妙的实现思路。还记得我们第11节中，在述排序算法的稳定性的时候举的订单的例子吗？我们这里也可以借助相同的处理思路，先按照最后一位来排序手机号码，然后，再按照倒数第二位重新排序，以此类推，最后按照第一位重新排序。经过11次排序之后，手机号码就都有序了手机号码稍微有点长，画图比较不容易看清楚，我用字符串排序的例子，画了一张基数排序的过程分解图，你可以看下。

注意，这里按照每位来排序的排序算法要是稳定的，否则这个实现思路就是不正确的。因为如果是非稳定排序算法，那最后一次排序只会考虑最高位的大小顺序，完全不管其他位的大小关系，那么低位的排序就完全没有意义了。
根据每一位来排序，我们可以用桶排序或者计数排序，它们的时间复杂度可以做到O（n）。如果要排序的数据有k位，那我们就需要k次桶排序或计数排序，总的时间复杂度是O（k*n）。当k不大的时候，比如手机号码排序，最大就是11，所以基数排序的时间复杂度就近似于O（n）。
实际上，有时候要排序的数据并不都是等长的，比如我们排序牛津字典中的20万个英文单词，最短的只有1个字母，最长的我特意去查了下，有45个字母，中文翻译是尘肺病。对于这种不等长的数据，基数排序还适用吗？实际上，我们可以把所有的单词补齐到相同长度，位数不够的可以在后面补“0”，因为根据ASCII值，所有字母都大于“0”，所以补“0”不会影响到原有的大小顺序。这样就可以继续用基数排序了。
我来总结一下，基数排序对要排序的数据是有要求的，需要可以分割出独立的“位”来比较，而且位之间有递进的关系，如果a数据的高位比b数据大，那剩下的低位就不用比较了。除此之外，每一位的数据范围不能太大，要可以用线性排序算法来排序，否则，基数排序的时间复杂度就无法做到0（n）了。

应用

如何根据年龄给100万用户排序？
实际上，根据年龄给100万用户排序，就类似按照成绩给50万考生排序。我们假设年龄的范围最小1岁，最大不超过120岁。我们可以遍历这100万用户，根据年龄将其划分到这120个桶里，然后依次顺序遍历这120个桶中的元素。这样就得到了按照年龄排序的100万用户数据

课后思考

我们今天讲的都是针对特殊数据的排序算法。实际上，还有很多看似是排序但又不需要使用排序算法就能处理的排序问题。
假设我们现在需要对D，a，F，B，c，A，z这个字符串进行排序，要求将其中所有小写字母都排在大写字母的前面，但小写字母内部和大写字母内部不要求有序。比如经过排序之后为a，c，z，D，F，B，A，这个如何来实现呢？如果字符串中存储的不仅有大小写字母，还有数字。要将小写字母的放到前面，大写字母放在最后，数字放在中间，不用排序算法，又该怎么解决呢？

• 用两个指针a、b：a指针从头开始往后遍历，遇到大写字母就停下，b从后往前遍历，遇到小写字母就停下，交换a、b指针对应的元素；重复如上过程，直到a、b指针相交。
• 利用桶排序思想，弄小写，大写，数字三个桶，遍历一遍，都放进去，然后再从桶中取出来就行了。相当于遍历了两遍，复杂度O(n)

排序优化

几乎所有的编程语言都会提供排序函数，比如C语言中qsort()，C++STL中的sort()、stable_sort()，还有Java语言中的Collections.sort()。在平时的开发中，我们也都是直接使用这些现成的函数来实现业务逻辑中的排序功能。那你知道这些排序函数是如何实现的吗？底层都利用了哪种排序算法呢？
如何实现一个通用的、高性能的排序函数？

线性排序算法的时间复杂度比较低，适用场景比较特殊。所以如果要写一个通用的排序函数，不能选择线性排序算法。
如果对小规模数据进行排序，可以选择时间复杂度是O（n2）的算法；如果对大规模数据进行排序，时间复杂度是O（nlogn）的算法更加高效。所以，为了兼顾任意规模数据的排序，一般都会首选时间复杂度是O（nlogn）的排序算法来实现排序函数。
时间复杂度是（nlogn）的排序算法不止一个，我们已经讲过的有归并排序、快速排序，后面讲堆的时候我们还会讲到堆排序。堆排序和快速排序都有比较多的应用，比如Java语言采用堆排序实现排序函数，C语言使用快速排序实现排序函数。
不知道你有没有发现，使用归并排序的情况其实并不多。我们知道，快排在最坏情况下的时间复杂度是O（n2）而归并排序可以做到平均情况、最坏情况下的时间复杂度都是0（nlogn），从这点上看起来很诱人，那为什么它还是没能得到“宠信”呢？
还记得我们上一节讲的归并排序的空间复杂度吗？归并排序并不是原地排序算法，空间复杂度是O（n）。所以，粗略点、夸张点讲，如果要排序100MB的数据，除了数据本身占用的内存之外，排序算法还要额外再占用100MB的内存空间，空间耗费就翻倍了。
前面我们讲到，快速排序比较适合来实现排序函数，但是，我们也知道，快速排序在最坏情况下的时间复杂度是0（n2），如何来解决这个“复杂度恶化”的问题呢？
如何优化快速排序？
我们先来看下，为什么最坏情况下快速排序的时间复杂度是O（n2）呢？我们前面讲过，如果数据原来就是有序的或者接近有序的，每次分区点都选择最后一个数据，那快速排序算法就会变得非常糟糕，时间复杂度就会退化为0（n2）。实际上，这种O（n2）时间复杂度出现的主要原因还是因为我们分区点选的不够合理。
那什么样的分区点是好的分区点呢？或者说如何来选择分区点呢？
最理想的分区点是：被分区点分开的两个分区中，数据的数量差不多。
如果很粗暴地直接选择第一个或者最后一个数据作为分区点，不考虑数据的特点，肯定会出现之前讲的那样，在某些情况下，排序的最坏情况时间复杂度是O（n2）。为了提高排序算法的性能，我们也要尽可能地让每次分区都比较平均。
我这里介绍两个比较常用、比较简单的分区算法
1.三数取中法
我们从区间的首、尾、中间，分别取出一个数，然后对比大小，取这3个数的中间值作为分区点。这样每间隔某个固定的长度，取数据出来比较，将中间值作为分区点的分区算法，肯定要比单纯取某一个数据更好。但是，如果要排序的数组比较大，那“三数取中”可能就不够了，可能要“五数取中”或者“十数取中”
2.随机法
随机法就是每次从要排序的区间中，随机选择一个元素作为分区点。这种方法并不能保证每次分区点都选的比较好，但是从概率的角度来看，也不大可能会出现每次分区点都选的很差的情况，所以平均情况下，这样选的分区点是比较好的。时间复杂度退化为最糟糕的O（n2）的情况，出现的可能性不大。
我们知道，快速排序是用递归来实现的。我们在递归那一节讲过，递归要警堆栈溢出。为了避免快速排序里递归过深而堆栈过小，导致堆栈溢出，我们有两种解决办法：第一种是限制递归深度。一旦递归过深，超过了我们事先设定的值，就停止递归。第二种是通过在堆上模拟实现一个函数调用栈，手动模拟递归压栈、出栈的过程，这样就没有了系统栈大小的限制
举例分析排序函数
为了让你对如何实现一个排序函数有一个更直观的感受，我拿Glibc中的qsort()函数举例说明一下。虽说qsort()从名字上看，很像是基于快速排序算法实现的，实际上它并不仅仅用了快排这一种算法。
如果你去看源码，你就会发现，qsort会优先使用归并排序来排序输入数据，因为归并排序的空间复杂度是O（n），所以对于小数据量的排序，比如1KB、2KB等，归并排序额外需要1KB、2KB的内存空间，这个问题不大。现在计算机的内存都挺大的，我们很多时候追求的是速度。还记得我们前面讲过的用空间换时间的技巧吗？这就是一个典型的应用。
但如果数据量太大，就跟我们前面提到的，排序100MB的数据，这个时候我们再用归并排序就不合适了。所以，要排序的数据量比较大的时候，qsort会改为用快速排序算法来排序。
那qsort是如何选择快速排序算法的分区点的呢？如果去看源码，你就会发现，qsort选择分区点的方法就是“三数取中法”。是不是也并不复杂？
还有我们前面提到的递归太深会导致堆栈溢出的问题，qsort是通过自己实现一个堆上的栈，手动模拟递归来解决的。我们之前在讲递归那一节也讲过，不知道你还有没有印象？
实际上，qsort并不仅仅用到了归并排序和快速排序，它还用到了插入排序。在快速排序的过程中，当要排序的区间中，元素的个数小于等于4时，qsort就退化为插入排序，不再继续用递归来做快速排序，因为我们前面也讲过，在小规模数据面前，O（n2）时间复杂度的算法并不一定比O（nlogn）的算法执行时间长。我们现在就来分析下这个说法。
我们在讲复杂度分析的时候讲过，算法的性能可以通过时间复杂度来分析，但是，这种复杂度分析是比较偏理论的，如果我们深究的话，实际上时间复杂度并不等于代码实际的运行时间
时间复杂度代表的是一个增长超势，如果画成增长曲线图，你会发现O（n2）比O（nlogn）要陡峭，也就是说增长超势要更猛一些。但是，我们前面讲过，在大复杂度表示法中，我们会省略低阶、系数和常数，也就是说，O（nlogn）在没有省略低阶、系数、常数之前可能是O（knlogn+c），而且k和c有可能还是一个比较大的数。假设k=1000，c=200，当我们对小规模数据（比如n=100）排序时，n的值实际上比knlogn+c还要小
所以，对于小规模数据的排序，O（n2）的排序算法并不一定比O（nlogn）排序算法执行的时间长。对于小数据量的排序，我们选择比较简单、不需要递归的插入排序算法。
还记得我们之前讲到的哨兵来简化代码，提高执行效率吗？在sort插入排序的算法实现中，也利用了这种编程技巧。虽然哨兵可能只是少做一次判断，但是毕竟排序函数是非常常用、非常基础的函数，性能的优化要做到极致。

课后思考

在今天的内容中，我分析了C语言的中的sort的底层排序算法，你能否分析一下你所熟悉的语言中的排序函数都是用什么排序算法实现的呢？都有哪些优化技巧？

查看了下Arrays.sort的源码，主要采用TimSort算法, 大致思路是这样的：

1 元素个数 < 32, 采用二分查找插入排序(Binary Sort)
2 元素个数 >= 32, 采用归并排序，归并的核心是分区(Run)
3 找连续升或降的序列作为分区，分区最终被调整为升序后压入栈
4 如果分区长度太小，通过二分插入排序扩充分区长度到分区最小阙值
5 每次压入栈，都要检查栈内已存在的分区是否满足合并条件，满足则进行合并
6 最终栈内的分区被全部合并，得到一个排序好的数组

Timsort的合并算法非常巧妙：

1 找出左分区最后一个元素(最大)及在右分区的位置
2 找出右分区第一个元素(最小)及在左分区的位置
3 仅对这两个位置之间的元素进行合并，之外的元素本身就是有序的

总结

小规模数据：插入排序

大规模数据：快排

特殊数据：

桶排序：数据需要很容易就能划分成m个桶，桶与桶之间有着天然的大小顺序。这样每个桶内的数据都排序完之后，桶与桶之间的数据不需要再进行排序。
其次，数据在各个桶之间的分布是比较均匀的。桶排序比较适合用在外部排序中。所谓的外部排序就是数据存储在外部磁盘中，数据量比较大，内存有限，无法将数据全部加载到内存中

计数排序：当要排序的n个数据，所处的范围并不大的时候，比如最大值是k，我们就可以把数据划分成k个桶。每个桶内的数据值都是相同的，省掉了桶内排序的时间。

基数排序：需要可以分割出独立的“位”来比较，而且位之间有递进的关系。比较两个数，我们只需要比较高位，高位相同的再比较低位。而且每一位的数据范围不能太大，因为基数排序算法需要借助桶排序或者计数排序来完成每一个位的排序工作。