冒泡排序法和快速排序比较的算法

打你屁股，这么简单的问题都不认真研究一下。

冒泡排序是最慢的排序，时间复杂度是 O(n^2)。

快速排序是最快的排序。关于快速排序，我推荐你看看《代码之美》第二章：我编写过的最漂亮的代码。作者所说的最漂亮，就是指效率最高的。

--------------------------------摘自《代码之美》---------------

当我撰写关于分治（divide-and-conquer）算法的论文时，我发现CAR Hoare的Quicksort算法（“Quicksort”，Computer Journal 5）无疑是各种Quicksort算法的鼻祖。这是一种解决基本问题的漂亮算法，可以用优雅的代码实现。我很喜欢这个算法，但我总是无法弄明白算法中最内层的循环。我曾经花两天的时间来调试一个使用了这个循环的复杂程序，并且几年以来，当我需要完成类似的任务时，我会很小心地复制这段代码。虽然这段代码能够解决我所遇到的问题，但我却并没有真正地理解它。

我后来从Nico Lomuto那里学到了一种优雅的划分（partitioning）模式，并且最终编写出了我能够理解，甚至能够证明的Quicksort算法。William Strunk Jr针对英语所提出的“良好的写作风格即为简练”这条经验同样适用于代码的编写，因此我遵循了他的建议，“省略不必要的字词”（来自《The Elements of Style》一书）。我最终将大约40行左右的代码缩减为十几行的代码。因此，如果要回答“你曾编写过的最漂亮代码是什么？”这个问题，那么我的答案就是：在我编写的《Programming Pearls, Second Edition》(Addison-Wesley)一书中给出的Quichsort算法。在示例2-1中给出了用C语言编写的Quicksort函数。我们在接下来的章节中将进一步地研究和改善这个函数。

示例 2-1 Quicksort函数

void quicksort(int l, int u)

{ int i, m;

if (l >= u) return; 10

swap(l, randint(l, u));

m = l;

for (i = l+1; i <= u; i++)

if (x[i] < x[l])

swap(++m, i);

swap(l, m);

quicksort(l, m-1);

quicksort(m+1, u);

}

如果函数的调用形式是quicksort(0, n-1)，那么这段代码将对一个全局数组x[n]进行排序。函数的两个参数分别是将要进行排序的子数组的下标：l是较低的下标，而u是较高的下标。函数调用swap(i,j)将会交换x[i]与x[j]这两个元素。第一次交换 *** 作将会按照均匀分布的方式在l和u之间随机地选择一个划分元素。

在《Programming Pearls》一书中包含了对Quicksort算法的详细推导以及正确性证明。在本章的剩余内容中，我将假设读者熟悉在《Programming Pearls》中所给出的Quicksort算法以及在大多数初级算法教科书中所给出的Quicksort算法。

如果你把问题改为“在你编写那些广为应用的代码中，哪一段代码是最漂亮的？”我的答案还是Quicksort算法。在我和M D McIlroy一起编写的一篇文章（"Engineering a sort function," Software-Practice and Experience, Vol 23, No 11）中指出了在原来Unix qsort函数中的一个严重的性能问题。随后，我们开始用C语言编写一个新排序函数库，并且考虑了许多不同的算法，包括合并排序（Merge Sort）和堆排序（Heap Sort）等算法。在比较了Quicksort的几种实现方案后，我们着手创建自己的Quicksort算法。在这篇文章中描述了我们如何设计出一个比这个算法的其他实现要更为清晰，速度更快以及更为健壮的新函数——部分原因是由于这个函数的代码更为短小。Gordon Bell的名言被证明是正确的：“在计算机系统中，那些最廉价，速度最快以及最为可靠的组件是不存在的。”现在，这个函数已经被使用了10多年的时间，并且没有出现任何故障。

考虑到通过缩减代码量所得到的好处，我最后以第三种方式来问自己在本章之初提出的问题。“你没有编写过的最漂亮代码是什么？”。我如何使用非常少的代码来实现大量的功能？答案还是和Quicksort有关，特别是对这个算法的性能分析。我将在下一节给出详细介绍。

22 事倍功半

Quicksort是一种优雅的算法，这一点有助于对这个算法进行细致的分析。大约在1980年左右，我与Tony Hoare曾经讨论过Quicksort算法的历史。他告诉我，当他最初开发出Quicksort时，他认为这种算法太简单了，不值得发表，而且直到能够分析出这种算法的预期运行时间之后，他才写出了经典的“Quicksoft”论文。

我们很容易看出，在最坏的情况下，Quicksort可能需要n2的时间来对数组元素进行排序。而在最优的情况下，它将选择中值作为划分元素，因此只需nlgn次的比较就可以完成对数组的排序。那么，对于n个不同值的随机数组来说，这个算法平均将进行多少次比较？

Hoare对于这个问题的分析非常漂亮，但不幸的是，其中所使用的数学知识超出了大多数程序员的理解范围。当我为本科生讲授Quicksort算法时，许多学生即使在费了很大的努力之后，还是无法理解其中的证明过程，这令我非常沮丧。下面，我们将从Hoare的程序开

11

始讨论，并且最后将给出一个与他的证明很接近的分析。

我们的任务是对示例2-1中的Quicksort代码进行修改，以分析在对元素值均不相同的数组进行排序时平均需要进行多少次比较。我们还将努力通过最短的代码、最短运行时间以及最小存储空间来得到最深的理解。

为了确定平均比较的次数，我们首先对程序进行修改以统计次数。因此，在内部循环进行比较之前，我们将增加变量comps的值（参见示例2-2）。

示例2-2 修改Quicksort的内部循环以统计比较次数。

for (i = l+1; i <= u; i++) {

comps++;

if (x[i] < x[l])

swap(++m, i);

}

如果用一个值n来运行程序，我们将会看到在程序的运行过程中总共进行了多少次比较。如果重复用n来运行程序，并且用统计的方法来分析结果，我们将得到Quicksort在对n个元素进行排序时平均使用了14 nlgn次的比较。

在理解程序的行为上，这是一种不错的方法。通过十三行的代码和一些实验可以反应出许多问题。这里，我们引用作家Blaise Pascal和T S Eliot的话，“如果我有更多的时间，那么我给你写的信就会更短。”现在，我们有充足的时间，因此就让我们来对代码进行修改，并且努力编写出更短（同时更好）的程序。

我们要做的事情就是提高这个算法的速度，并且尽量增加统计的精确度以及对程序的理解。由于内部循环总是会执行u-l次比较，因此我们可以通过在循环外部增加一个简单的 *** 作来统计比较次数，这就可以使程序运行得更快一些。在示例2-3的Quicksort算法中给出了这个修改。

示例2-3 Quicksort的内部循环，将递增 *** 作移到循环的外部

comps += u-l;

for (i = l+1; i <= u; i++)

if (x[i] < x[l])

swap(++m, i);

这个程序会对一个数组进行排序，同时统计比较的次数。不过，如果我们的目标只是统计比较的次数，那么就不需要对数组进行实际地排序。在示例2-4中去掉了对元素进行排序的“实际 *** 作”，而只是保留了程序中各种函数调用的“框架”。

示例2-4将Quicksort算法的框架缩减为只进行统计

void quickcount(int l, int u)

{ int m;

if (l >= u) return;

m = randint(l, u);

comps += u-l;

quickcount(l, m-1);

quickcount(m+1, u);

}

12

这个程序能够实现我们的需求，因为Quichsort在选择划分元素时采用的是“随机”方式，并且我们假设所有的元素都是不相等的。现在，这个新程序的运行时间与n成正比，并且相对于示例2-3需要的存储空间与n成正比来说，现在所需的存储空间缩减为递归堆栈的大小，即存储空间的平均大小与lgn成正比。

虽然在实际的程序中，数组的下标（l和u）是非常重要的，但在这个框架版本中并不重要。因此，我们可以用一个表示子数组大小的整数(n)来替代这两个下标（参见示例2-5）

示例2-5 在Quicksort代码框架中使用一个表示子数组大小的参数

void qc(int n)

{ int m;

if (n <= 1) return;

m = randint(1, n);

comps += n-1;

qc(m-1);

qc(n-m);

}

现在，我们可以很自然地把这个过程整理为一个统计比较次数的函数，这个函数将返回在随机Quicksort算法中的比较次数。在示例2-6中给出了这个函数。

示例2-6 将Quicksort框架实现为一个函数

int cc(int n)

{ int m;

if (n <= 1) return 0;

m = randint(1, n);

return n-1 + cc(m-1) + cc(n-m);

}

在示例2-4、示例2-5和示例2-6中解决的都是相同的基本问题，并且所需的都是相同的运行时间和存储空间。在后面的每个示例都对这些函数的形式进行了改进，从而比这些函数更为清晰和简洁。

在定义发明家的矛盾（inventor's paradox）(How To Solve It, Princeton University Press)时，George Póllya指出“计划越宏大，成功的可能性就越大。”现在，我们就来研究在分析Quicksort时的矛盾。到目前为止，我们遇到的问题是，“当Quicksort对大小为n的数组进行一次排序时，需要进行多少次比较？”我们现在将对这个问题进行扩展，“对于大小为n的随机数组来说，Quichsort算法平均需要进行多少次的比较？”我们通过对示例2-6进行扩展以引出示例2-7。

示例2-7 伪码：Quicksort的平均比较次数

float c(int n)

if (n <= 1) return 0

sum = 0

for (m = 1; m <= n; m++)

sum += n-1 + c(m-1) + c(n-m)

return sum/n

如果在输入的数组中最多只有一个元素，那么Quichsort将不会进行比较，如示例2-6

13

中所示。对于更大的n，这段代码将考虑每个划分值m（从第一个元素到最后一个，每个都是等可能的）并且确定在这个元素的位置上进行划分的运行开销。然后，这段代码将统计这些开销的总和（这样就递归地解决了一个大小为m-1的问题和一个大小为n-m的问题），然后将总和除以n得到平均值并返回这个结果。

如果我们能够计算这个数值，那么将使我们实验的功能更加强大。我们现在无需对一个n值运行多次来估计平均值，而只需一个简单的实验便可以得到真实的平均值。不幸的是，实现这个功能是要付出代价的：这个程序的运行时间正比于3n（如果是自行参考（self-referential）的，那么用本章中给出的技术来分析运行时间将是一个很有趣的练习）。

示例2-7中的代码需要一定的时间开销，因为它重复计算了中间结果。当在程序中出现这种情况时，我们通常会使用动态编程来存储中间结果，从而避免重复计算。因此，我们将定义一个表t[N+1]，其中在t[n]中存储c[n]，并且按照升序来计算它的值。我们将用N来表示n的最大值，也就是进行排序的数组的大小。在示例2-8中给出了修改后的代码。

示例2-8 在Quicksort中使用动态编程来计算

t[0] = 0

for (n = 1; n <= N; n++)

sum = 0

for (i = 1; i <= n; i++)

sum += n-1 + t[i-1] + t[n-i]

t[n] = sum/n

这个程序只对示例2-7进行了细微的修改，即用t[n]来替换c(n)。它的运行时间将正比于N2，并且所需的存储空间正比于N。这个程序的优点之一就是：在程序执行结束时，数组t中将包含数组中从元素0到元素N的真实平均值（而不是样本均值的估计）。我们可以对这些值进行分析，从而生成在Quichsort算法中统计比较次数的计算公式。

我们现在来对程序做进一步的简化。第一步就是把n-1移到循环的外面，如示例2-9所示。

示例2-9 在Quicksort中把代码移到循环外面来计算

t[0] = 0

for (n = 1; n <= N; n++)

sum = 0

for (i = 1; i <= n; i++)

sum += t[i-1] + t[n-i]

t[n] = n-1 + sum/n

现在将利用对称性来对循环做进一步的调整。例如，当n为4时，内部循环计算总和为：

t[0]+t[3] + t[1]+t[2] + t[2]+t[1] + t[3]+t[0]

在上面这些组对中，第一个元素增加而第二个元素减少。因此，我们可以把总和改写为：

2 (t[0] + t[1] + t[2] + t[3])

我们可以利用这种对称性来得到示例2-10中的Quicksort。

示例2-10 在Quichsort中利用了对称性来计算

t[0] = 0

14

for (n = 1; n <= N; n++)

sum = 0

for (i = 0; i < n; i++)

sum += 2 t[i]

t[n] = n-1 + sum/n

然而，在这段代码的运行时间中同样存在着浪费，因为它重复地计算了相同的总和。此时，我们不是把前面所有的元素加在一起，而是在循环外部初始化总和并且加上下一个元素，如示例2-11所示。

示例2-11 在Quicksort中删除了内部循环来计算

sum = 0; t[0] = 0

for (n = 1; n <= N; n++)

sum += 2t[n-1]

t[n] = n-1 + sum/n

这个小程序确实很有用。程序的运行时间与N成正比，对于每个从1到N的整数，程序将生成一张Quicksort的估计运行时间表。

我们可以很容易地把示例2-11用表格来实现，其中的值可以立即用于进一步的分析。在2-1给出了最初的结果行。

表2-1 示例2-11中实现的表格输出

N Sum t[n]

0 0 0

1 0 0

2 0 1

3 2 2667

4 7333 4833

5 17 74

6 318 103

7 524 13486

8 79371 16921

这张表中的第一行数字是用代码中的三个常量来进行初始化的。下一行（输出的第三行）的数值是通过以下公式来计算的：

A3 = A2+1 B3 = B2 + 2C2 C3 = A2-1 + B3/A3

把这些（相应的）公式记录下来就使得这张表格变得完整了。这张表格是“我曾经编写的最漂亮代码”的很好的证据，即使用少量的代码完成大量的工作。

但是，如果我们不需要所有的值，那么情况将会是什么样？如果我们更希望通过这种来方式分析一部分数值（例如，在20到232之间所有2的指数值）呢？虽然在示例2-11中构建了完整的表格t，但它只需要使用表格中的最新值。因此，我们可以用变量t的定长空间来替代table t[]的线性空间，如示例2-12所示。

示例2-12 Quicksoft 计算——最终版本

sum = 0; t = 0

15

for (n = 1; n <= N; n++)

sum += 2t

t = n-1 + sum/n

然后，我们可以插入一行代码来测试n的适应性，并且在必要时输出这些结果。

这个程序是我们漫长学习旅途的终点。通过本章所采用的方式，我们可以证明Alan Perlis的经验是正确的：“简单性并不是在复杂性之前，而是在复杂性之后” ("Epigrams on Programming," Sigplan Notices, Vol 17, Issue 9)。

这个有趣的编程语言的话，大概还分两种，一种是实际应用中真正用来应用的，而另外一种，是纯粹娱乐的，真正应用是用不到，也用不了的。冷门语言的第一大流派，首屈一指应当算是LISP了。虽然说LISP冷门，但是绝对是冷门中的霸主（还是冷门）。而且论资排辈，LISP是世界上至今还在使用的高级编程语言中第二老的（FORTRAN第一），由人工智能之父John McCarthy于1958年设计并实现。和UNIX一样，今天已经没有LISP，但是有LISP的一些方言和衍生语言，比如Common LISP、Emacs LISP、AutoLISP和Scheme等等。作为一种函数式编程语言，他的程序书写的思路和我们常见的过程式（包括面向对象和非面向对象）的语言差异很大，不好掌握。不过掌握的人都认为很好用。一直流传的一个这样的说法，「真正的程序员用C写程序，聪明的程序员用Delphi写程序，天才的程序员用LISP写程序」，可见这个语言的地位。另外值得一提的是，现在的高级编程语言的许多特性和概念，比如函数式编程、Lambda表达式、垃圾回收、大整数自动转换等等，都是从LISP中借鉴吸取的。然后说几个我只是听说过一些，但不是非常了解的语言。Erlang，是由爱立信开发的一种适合于并行编程的语言。Prolog，一种逻辑编程语言，建立在逻辑学理论基础上，最初被用来做自然语言处理，现在广泛应用在人工智能研究中。Haskell，一种纯函数式编程语言，目前似乎也有挺多人对这个感兴趣的。AWK，由著名的编译原理（龙书）的作者Alfred Aho设计并实现的一种编程语言，是一种非常优秀的文本处理工具，也是Linux和Unix环境中功能最强大的数据处理引擎之一。R语言，一种适合于数据统计和分析的编程语言。对于那些没有用的语言，有一些是用来娱乐，有一些是用来做学术研究的。这些“没有用”的语言的最大的一个代表，就是brainfuck语言。brainfuck是一种极简单的语言，或者准确的说是一套编程指令，详细的说明可以详见文后参考资料。指令总共只有8条，虽然指令书很少，但是被证明是一种图灵完全的语言，也就是，C语言能实现的所有算法，用brainfuck也可以实现。因为功能和原理特别简单，个人认为，brainfuck是简单功能虚拟机、C语言编程练习、C语言程序设计练习的非常好的学习和练习材料。LOLCODE也是一种很特别的语言，里面的关键字很口语化，都是一些网络用语。Whitespace，非常难阅读的编程语言。这种语言更可怕了，有效只有空格、制表符和换行符。由这一些空白字符的组合来表示这种指令。Shakespeare，正如这种语言的名字一样，他的程序写出来就像是莎翁写的剧本。Chef，跟Shakespeare有些类似，不同的是，他的程序写出来像是个菜谱。Piet，这个编程语言不是用语言来编程的，而是，用位图。不同颜色的像素表示不同的指令和数据。

APP算法是指应用程序中使用的一种根据用户的行为、偏好、需求等数据，来生成个性化推荐、广告、内容等的技术。APP算法可以帮助用户发现更多有价值或有趣的信息，提高用户的体验和满意度，也可以帮助应用程序提高流量和收入。然而，APP算法也存在一些风险和问题，可能会侵犯用户的隐私和权益，影响用户的判断和选择，甚至危害用户的安全和利益。我们应该如何保护自己的隐私和权益呢？我认为，需要从以下几个方面来进行：

第一，提高自己的网络安全意识和能力。我们应该了解APP算法的原理和风险，警惕一些不良或不合法的APP算法，比如恶意搜集或泄露用户的个人信息、敏感信息、生物特征等，比如利用用户的心理弱点或认知偏差来诱导或 *** 纵用户的行为、消费、决策等，比如传播虚假或有害的信息、广告、内容等。我们应该选择正规和可信的应用程序，避免下载或使用一些来源不明或质量低劣的应用程序。我们应该设置合理和安全的密码、权限、防火墙等，避免被黑客或病毒攻击或感染。我们应该定期清理或删除一些不需要或不使用的应用程序、账号、数据等，避免占用空间或造成垃圾。

第二，保护自己的个人信息和隐私权利。我们应该阅读并理解应用程序的隐私政策和用户协议，了解它们会收集、使用、存储、共享、转让、删除等我们的哪些信息，以及我们有哪些权利和义务。我们应该控制并最小化我们向应用程序提供或授权的信息，只提供必要或合理的信息，拒绝或撤销不必要或不合理的信息。我们应该监督并要求应用程序遵守相关法律法规和道德规范，尊重并保护我们的个人信息和隐私权利。如果发现应用程序违法违规或侵犯我们的个人信息和隐私权利，我们应该及时投诉举报或维权诉讼。

第三，保持自己的独立思考和判断能力。我们应该认识到APP算法并不完美或客观，它们可能会受到一些因素的影响或干扰，比如数据质量、算法设计、商业利益、社会价值等。我们应该批判地分析并评估APP算法给我们推荐、广告、内容等的真实性、有效性、合理性、公正性等。我们应该主动地探索并获取更多更广更深的信息，不要局限于APP算法给我们呈现的信息，避免陷入信息茧房或信息过滤泡。我们应该自主地做出我们的选择和决策，不要盲目地跟随或依赖APP算法给我们的建议或指导，避免被 *** 纵或误导。

第四，维护自己的合法利益和社会责任。我们应该利用APP算法为我们提供的有价值或有趣的信息，来提高我们的知识水平、技能能力、生活质量等，但是也要注意控制我们的时间和精力，避免沉迷或浪费。我们应该利用APP算法为我们提供的有益或有用的信息，来促进我们的事业发展、社会交流、公共服务等，但是也要注意保持我们的道德标准、法律规范、社会秩序等，避免违法或不良。我们应该利用APP算法为我们提供的有意义或有价值的信息，来增进我们的个人成长、社会参与、公民意识等，但是也要注意尊重他人的权利和利益，避免侵犯或损害。

总之，APP算法是一把双刃剑，既有好处也有风险。我们应该既享受其带来的便利和乐趣，也防范其带来的危害和问题。我们应该从提高自己的网络安全意识和能力、保护自己的个人信息和隐私权利、保持自己的独立思考和判断能力、维护自己的合法利益和社会责任等方面来进行，从而实现与APP算法的良性互动和共赢发展。

Jump-pointer: 在作LA(v,d)的时候, 如果一层一层的往上搜索很慢 有没有可能直接跳呢 比如我们知道LA(u,d) = LA(v,d),如果u是v的一个ancestor 如果直接储存了LA(u,d), 并且可以在log(n)的时间"跳"到u, 那么只要log n的时间就能找到LA(v,d) 这个算法要用 O(n log n)的preprocess time + O(log n)的time 每一次跳的距离是上一次的1/2倍，[这个算法很简单的]。

以上就是关于冒泡排序法和快速排序比较的算法全部的内容，包括:冒泡排序法和快速排序比较的算法、有哪些冷门但很有意思的编程语言、APP算法是什么等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！