python冒泡排序算法时间复杂度为nlogn_〔算法〕排序的最低时间复杂度为什么是O？（nlogn）...

我们来算一下最坏情况下三种算法各需要多少次比较和赋值操作。

选择排序在第i次选择时赋值和比较都需要n-i次(在n-i+1个数中选一个出来作为当前最小值，其余n-i个数与当前最小值比较并不断更新当前最小值)，然后需要一次赋值操作。总共需要n(n-1)/2次比较与n(n-1)/2+n次赋值。

插入排序在第i次寻找插入位置时需要最多i-1次比较(从后往前找到第一个比待插入的数小的数，最坏情况发生在这个数是所有已经取出的数中最小的一个的时 候)，在已有数列中给新的数腾出位置需要i-1次赋值操作来实现，还需要两次赋值借助临时变量把新取出的数搬进搬出。也就是说，最坏情况下比较需要n(n -1)/2次，赋值需要n(n-1)/2+2n次。我这么写有点误导人，大家不要以为程序的实现用了两个数组哦，其实一个数组就够了，看看上面的演示就知 道了。我只说算法，一般不写如何实现。学算法的都是强人，知道算法了都能写出一个漂亮的代码来。

冒泡排序第i趟排序需要比较n-i次，n-1趟排序总共n(n-1)/2次。给出的序列逆序排列是最坏的情况，这时每一次比较都要进行交换操作。一次交换操作需要3次赋值实现，因此冒泡排序最坏情况下需要赋值3n(n-1)/2次。

按照渐进复杂度理论，忽略所有的常数，三种排序的最坏情况下复杂度都是一样的：O(n^2)。但实际应用中三种排序的效率并不相同。实践证明(政治考试时 每道大题都要用这四个字)，插入排序是最快的(虽然最坏情况下与选择排序相当甚至更糟)，因为每一次插入时寻找插入的位置多数情况只需要与已有数的一部分 进行比较(你可能知道这还能二分)。你或许会说冒泡排序也可以在半路上完成，还没有跑到第n-1趟就已经有序。但冒泡排序的交换操作更费时，而插入排序中 找到了插入的位置后移动操作只需要用赋值就能完成(你可能知道这还能用move)。本文后面将介绍的一种算法就利用插入排序的这些优势。

我们证明了，三种排序方法在最坏情况下时间复杂度都是O(n^2)。但大家想过吗，这只是最坏情况下的。在很多时候，复杂度没有这么大，因为插入和冒泡在 数列已经比较有序的情况下需要的操作远远低于n^2次(最好情况下甚至是线性的)。抛开选择排序不说(因为它的复杂度是“死”的，对于选择排序没有什么 “好”的情况)，我们下面探讨插入排序和冒泡排序在特定数据和平均情况下的复杂度。

你会发现，如果把插入排序中的移动赋值操作看作是把当 前取出的元素与前面取出的且比它大的数逐一交换，那插入排序和冒泡排序对数据的变动其实都是相邻元素的交换操作。下面我们说明，若只能对数列中相邻的数进 行交换操作，如何计算使得n个数变得有序最少需要的交换次数。

我们定义逆序对的概念。假设我们要把数列从小到大排序，一个逆序对是指的在 原数列中，左边的某个数比右边的大。也就是说，如果找到了某个i和j使得iAj，我们就说我们找到了一个逆序对。比如说，数列 3,1,4,2中有三个逆序对，而一个已经有序的数列逆序对个数为0。我们发现，交换两个相邻的数最多消除一个逆序对，且冒泡排序(或插入排序)中的一次 交换恰好能消除一个逆序对。那么显然，原数列中有多少个逆序对冒泡排序(或插入排序)就需要多少次交换操作，这个操作次数不可能再少。

若 给出的n个数中有m个逆序对，插入排序的时间复杂度可以说是O(m+n)的，而冒泡排序不能这么说，因为冒泡排序有很多“无用”的比较(比较后没有交 换)，这些无用的比较超过了O(m+n)个。从这个意义上说，插入排序仍然更为优秀，因为冒泡排序的复杂度要受到它跑的趟数的制约。一个典型的例子是这样 的数列：8, 2, 3, 4, 5, 6, 7, 1。在这样的输入数据下插入排序的优势非常明显，冒泡排序只能哭着喊上天不公。

然而，我们并不想计算排序算法对于某个特定数据的效率。我们真正关心的是，对于所有可能出现的数据，算法的平均复杂度是多少。不用激动了，平均复杂度并不会低于平方。下面证明，两种算法的平均复杂度仍然是O(n^2)的。

我们仅仅证明算法需要的交换次数平均为O(n^2)就足够了。前面已经说过，它们需要的交换次数与逆序对的个数相同。我们将证明，n个数的数列中逆序对个数平均O(n^2)个。

计算的方法是十分巧妙的。如果把给出的数列反过来(从后往前倒过来写)，你会发现原来的逆序对现在变成顺序的了，而原来所有的非逆序对现在都成逆序了。正 反两个数列的逆序对个数加起来正好就是数列所有数对的个数，它等于n(n-1)/2。于是，平均每个数列有n(n-1)/4个逆序对。忽略常数，逆序对平 均个数O(n^2)。

上面的讨论启示我们，要想搞出一个复杂度低于平方级别的排序算法，我们需要想办法能把离得老远的两个数进行操作。

人们想啊想啊想啊，怎么都想不出怎样才能搞出复杂度低于平方的算法。后来，英雄出现了，Donald Shell发明了一种新的算法，我们将证明它的复杂度最坏情况下也没有O(n^2) (似乎有人不喜欢研究正确性和复杂度的证明，我会用实例告诉大家，这些证明是非常有意思的)。他把这种算法叫做Shell增量排序算法(大家常说的希尔排 序)。

Shell排序算法依赖一种称之为“排序增量”的数列，不同的增量将导致不同的效率。假如我们对20个数进行排序，使用的增量为 1,3,7。那么，我们首先对这20个数进行“7-排序”(7-sortedness)。所谓7-排序，就是按照位置除以7的余数分组进行排序。具体地 说，我们将把在1、8、15三个位置上的数进行排序，将第2、9、16个数进行排序，依此类推。这样，对于任意一个数字k，单看A(k), A(k+7), A(k+14), ...这些数是有序的。7-排序后，我们接着又进行一趟3-排序(别忘了我们使用的排序增量为1,3,7)。最后进行1-排序(即普通的排序)后整个 Shell算法完成。看看我们的例子：

3 7 9 0 5 1 6 8 4 2 0 6 1 5 7 3 4 9 8 2  

3 3 2 0 5 1 5 7 4 4 0 6 1 6 8 7 9 9 8 2  

0 0 1 1 2 2 3 3 4 4 5 6 5 6 8 7 7 9 8 9  

0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9  

在每一趟、每一组的排序中我们总是使用插入排序。仔细观察上面的例子你会发现是什么导致了Shell排序的高效。对，每一趟排序将使得数列部分有序，从而 使得以后的插入排序很快找到插入位置。我们下面将紧紧围绕这一点来证明Shell排序算法的时间复杂度上界。

只要排序增量的第一个数是1，Shell排序算法就是正确的。但是不同的增量将导致不同的时间复杂度。我们上面例子中的增量(1, 3, 7, 15, 31, ..., 2^k-1)是使用最广泛的增量序列之一，可以证明使用这个增量的时间复杂度为O(n√n)。这个证明很简单，大家可以参看一些其它的资料，我们今天不证 明它。今天我们证明，使用增量1, 2, 3, 4, 6, 8, 9, 12, 16, ..., 2^p*3^q，时间复杂度为O(n*(log n)^2)。

很显然，任何一个大于1的正整数都可以表示为2x+3y，其中x和y是非负整数。于是，如果一个数列已经是2-排序的且是3 -排序的，那么对于此时数列中的每一个数A(i)，它的左边比它大的只有可能是A(i-1)。A2绝对不可能比A12大，因为10可以表示为两个2和两个 3的和，则A2

我们自然会想，有没有能使复杂度降到O(nlogn)甚至更低的增量序列。很遗憾，现在没有任何迹象表明存在O(nlogn)的增量排序。但事实上，很多时候Shell排序的实际效率超过了O(nlogn)的排序算法。

后面我们将介绍三种O(nlogn)的排序算法和三种线性时间的排序算法。最后我们将以外部排序和排序网络结束这一章节。

本文被华丽的分割线分为了四段。对于O(nlogn)的排序算法，我们详细介绍归并排序并证明归并排序的时间复杂度，然后简单介绍堆排序，之后给出快速排 序的基本思想和复杂度证明。最后我们将证明，O(nlogn)在理论上已经达到了最优。学过OI的人一般都学过这些很基础的东西，大多数OIer们不必看 了。为了保持系列文章的完整性，我还是花时间写了一下。

首先考虑一个简单的问题：如何在线性的时间内将两个有序队列合并为一个有序队列(并输出)？

A队列：1 3 5 7 9

B队列：1 2 7 8 9

看上面的例子，AB两个序列都是已经有序的了。在给出数据已经有序的情况下，我们会发现很多神奇的事，比如，我们将要输出的第一个数一定来自于这两个序列各自最前面的那个数。两个数都是1，那么我们随便取出一个(比如A队列的那个1)并输出：

A队列：1 3 5 7 9

B队列：1 2 7 8 9

输出：1

注意，我们取出了一个数，在原数列中删除这个数。删除操作是通过移动队首指针实现的，否则复杂度就高了。

现在，A队列打头的数变成3了，B队列的队首仍然是1。此时，我们再比较3和1哪个大并输出小的那个数：

A队列：1 3 5 7 9

B队列：1 2 7 8 9

输出：1 1

接下来的几步如下：

A队列：1 3 5 7 9         A队列：1 3 5 7 9         A队列：1 3 5 7 9           A队列：1 3 5 7 9

B队列：1 2 7 8 9   ==>   B队列：1 2 7 8 9   ==>   B队列：1 2 7 8 9     ==>   B队列：1 2 7 8 9     ……

输出：1 1 2               输出：1 1 2 3             输出：1 1 2 3 5           输出：1 1 2 3 5 7

我希望你明白了这是怎么做的。这个做法显然是正确的，复杂度显然是线性。

归并排序(Merge Sort)将会用到上面所说的合并操作。给出一个数列，归并排序利用合并操作在O(nlogn)的时间内将数列从小到大排序。归并排序用的是分治 (Divide and Conquer)的思想。首先我们把给出的数列平分为左右两段，然后对两段数列分别进行排序，最后用刚才的合并算法把这两段(已经排过序的)数列合并为一 个数列。有人会问“对左右两段数列分别排序时用的什么排序”么？答案是：用归并排序。也就是说，我们递归地把每一段数列又分成两段进行上述操作。你不需要 关心实际上是怎么操作的，我们的程序代码将递归调用该过程直到数列不能再分(只有一个数)为止。

初看这个算法时有人会误以为时间复杂度相当高。我们下面给出的一个图将用非递归的眼光来看归并排序的实际操作过程，供大家参考。我们可以借助这个图证明，归并排序算法的时间复杂度为O(nlogn)。

[3] [1] [4] [1] [5] [9] [2] [7]

\ /     \ /     \ /     \ /

[1 3]   [1 4]   [5 9]   [2 7]

\   /           \   /

[1 1 3 4]       [2 5 7 9]

\       /

[1 1 2 3 4 5 7 9]

上图中的每一个“ \ / ”表示的是上文所述的线性时间合并操作。上图用了4行来图解归并排序。如果有n个数，表示成上图显然需要O(logn)行。每一行的合并操作复杂度总和都 是O(n)，那么logn行的总复杂度为O(nlogn)。这相当于用递归树的方法对归并排序的复杂度进行了分析。假设，归并排序的复杂度为T(n)，T (n)由两个T(n/2)和一个关于n的线性时间组成，那么T(n)=2*T(n/2)+O(n)。不断展开这个式子我们可以同样可以得到T(n)=O (nlogn)的结论，你可以自己试试。如果你能在线性的时间里把分别计算出的两组不同数据的结果合并在一起，根据T(n)=2*T(n/2)+O(n) =O(nlogn)，那么我们就可以构造O(nlogn)的分治算法。这个结论后面经常用。我们将在计算几何部分举一大堆类似的例子。

如果你第一次见到这么诡异的算法，你可能会对这个感 兴趣。分治是递归的一种应用。这是我们第一次接触递归运算。下面说的快速排序也是用的递归的思想。递归程序的复杂度分析通常和上面一样，主定理 (Master Theory)可以简化这个分析过程。主定理和本文内容离得太远，我们以后也不会用它，因此我们不介绍它，大家可以自己去查。有个名词在这里的话找学习资 料将变得非常容易，我最怕的就是一个东西不知道叫什么名字，半天找不到资料。

归并排序有一个有趣的副产品。利用归并排序能够在O (nlogn)的时间里计算出给定序列里逆序对的个数。你可以用任何一种平衡二叉树来完成这个操作，但用归并排序统计逆序对更方便。我们讨论逆序对一般是 说的一个排列中的逆序对，因此这里我们假设所有数不相同。假如我们想要数1, 6, 3, 2, 5, 4中有多少个逆序对，我们首先把这个数列分为左右两段。那么一个逆序对只可能有三种情况：两个数都在左边，两个数都在右边，一个在左一个在右。在左右两段 分别处理完后，线性合并的过程中我们可以顺便算出所有第三种情况的逆序对有多少个。换句话说，我们能在线性的时间里统计出A队列的某个数比B队列的某个数 大有多少种情况。

A队列：1 3 6         A队列：1 3 6         A队列：1 3 6         A队列：1 3 6         A队列：1 3 6

B队列：2 4 5   ==>   B队列：2 4 5   ==>   B队列：2 4 5   ==>   B队列：2 4 5   ==>   B队列：2 4 5   ……

输出：               输出：1               输出：1 2             输出：1 2 3           输出：1 2 3 4

每一次从B队列取出一个数时，我们就知道了在A队列中有多少个数比B队列的这个数大，它等于A队列现在还剩的数的个数。比如，当我们从B队列中取出2时， 我们同时知道了A队列的3和6两个数比2大。在合并操作中我们不断更新A队列中还剩几个数，在每次从B队列中取出一个数时把当前A队列剩的数目加进最终答 案里。这样我们算出了所有“大的数在前一半，小的数在后一半”的情况，其余情况下的逆序对在这之前已经被递归地算过了。

============================华丽的分割线============================

堆排序(Heap Sort)利用了堆(Heap)这种数据结构(什么是堆？)。 堆的插入操作是平均常数的，而删除一个根节点需要花费O(log n)的时间。因此，完成堆排序需要线性时间建立堆(把所有元素依次插入一个堆)，然后用总共O(nlogn)的时间不断取出最小的那个数。只要堆会搞，堆 排序就会搞。堆在那篇日志里有详细的说明，因此这里不重复说了。

============================华丽的分割线============================

快速排序(Quick Sort)也应用了递归的思想。我们想要把给定序列分成两段，并对这两段分别进行排序。一种不错的想法是，选取一个数作为“关键字”，并把其它数分割为两 部分，把所有小于关键字的数都放在关键字的左边，大于关键字的都放在右边，然后递归地对左边和右边进行排序。把该区间内的所有数依次与关键字比较，我们就 可以在线性的时间里完成分割的操作。完成分割操作有很多有技巧性的实现方法，比如最常用的一种是定义两个指针，一个从前往后找找到比关键字大的，一个从后 往前找到比关键字小的，然后两个指针对应的元素交换位置并继续移动指针重复刚才的过程。这只是大致的方法，具体的实现还有很多细节问题。快速排序是我们最 常用的代码之一，网上的快速排序代码五花八门，各种语言，各种风格的都有。大家可以随便找一个来看看，我说过了我们讲算法但不讲如何实现。NOIp很简 单，很多人NOIp前就背了一个快速排序代码就上战场了。当时我把快速排序背完了，抓紧时间还顺便背了一下历史，免得晚上听写又不及格。

不像归并排序，快速排序的时间复杂度很难计算。我们可以看到，归并排序的复杂度最坏情况下也是O(nlogn)的，而快速排序的最坏情况是O(n^2) 的。如果每一次选的关键字都是当前区间里最大(或最小)的数，那么这样将使得每一次的规模只减小一个数，这和插入排序、选择排序等平方级排序没有区别。这 种情况不是不可能发生。如果你每次选择关键字都是选择的该区间的第一个数，而给你的数据恰好又是已经有序的，那你的快速排序就完蛋了。显然，最好情况是每 一次选的数正好就是中位数，这将把该区间平分为两段，复杂度和前面讨论的归并排序一模一样。根据这一点，快速排序有一些常用的优化。比如，我们经常从数列 中随机取一个数当作是关键字(而不是每次总是取固定位置上的数)，从而尽可能避免某些特殊的数据所导致的低效。更好的做法是随机取三个数并选择这三个数的 中位数作为关键字。而对三个数的随机取值反而将花费更多的时间，因此我们的这三个数可以分别取数列的头一个数、末一个数和正中间那个数。另外，当递归到了 一定深度发现当前区间里的数只有几个或十几个时，继续递归下去反而费时，不如返回插入排序后的结果。这种方法同时避免了当数字太少时递归操作出错的可能。

下面我们证明，快速排序算法的平均复杂度为O(nlogn)。不同的书上有不同的解释方法，这里我选用算法导论上的讲法。它更有技巧性一些，更有趣一些，需要转几个弯才能想明白。

看一看快速排序的代码。正如我们提到过的那种分割方法，程序在经过若干次与关键字的比较后才进行一次交换，因此比较的次数比交换次数更多。我们通过证明一 次快速排序中元素之间的比较次数平均为O(nlogn)来说明快速排序算法的平均复杂度。证明的关键在于，我们需要算出某两个元素在整个算法过程中进行过 比较的概率。

我们举一个例子。假如给出了1到10这10个数，第一次选择关键字7将它们分成了{1,2,3,4,5,6}和 {8,9,10}两部分，递归左边时我们选择了3作为关键字，使得左部分又被分割为{1,2}和{4,5,6}。我们看到，数字7与其它所有数都比较过一 次，这样才能实现分割操作。同样地，1到6这6个数都需要与3进行一次比较(除了它本身之外)。然而，3和9决不可能相互比较过，2和6也不可能进行过比 较，因为第一次出现在3和9，2和6之间的关键字把它们分割开了。也就是说，两个数A(i)和A(j)比较过，当且仅当第一个满足A(i)<= x<=A(j)的关键字x恰好就是A(i)或A(j) (假设A(i)比A(j)小)。我们称排序后第i小的数为Z(i)，假设i

现在有四个数，2,3,5,7。排序时，相邻的两个数肯定都被比较过，2和5、3和7都有2/3的概率被比较过，2和7之间被比较过有2/4的可能。也就 是说，如果对这四个数做12次快速排序，那么2和3、3和5、5和7之间一共比较了12*3=36次，2和5、3和7之间总共比较了8*2=16次，2和 7之间平均比较了6次。那么，12次排序中总的比较次数期望值为36+16+6=58。我们可以计算出单次的快速排序平均比较了多少次：58/12= 29/6。其实，它就等于6项概率之和，1+1+1+2/3+2/3+2/4=29/6。这其实是与期望值相关的一个公式。

同样地，如果有n个数，那么快速排序平均需要的比较次数可以写成下面的式子。令k=j-i，我们能够最终得到比较次数的期望值为O(nlogn)。

这里用到了一个知识：1+1/2+1/3+...+1/n与log n增长速度相同，即Σ(1/n)=Θ(log n)。它的证明放在本文的最后。

◆◆

评论读取中....

请登录后再发表评论!

◆◆

修改失败，请稍后尝试