算法导论第三版第五章课后答案

㈠ 求算法导论16章3-5，3-8的答案

3-8 Show that we cannot expect to compress a file of randomly chosen bits. Notice that the number of possible source files S using n bits and compressed files E using n bits is 2n+1 - 1. Since any compression algorithm must assign each element s 属于 S to a distinct element e 属于 E the algorithm cannot hope to actually compress the source file.

㈡ 《算法导论第三版》pdf下载在线阅读全文，求百度网盘云资源

《算法导论第三版》网络网盘pdf最新全集下载:
链接: https://pan..com/s/1Kqtznm5T7OhD9ZqI-6VAiQ

㈢ 《算法导论》第二章-思考题（参考答案）

插入排序的渐进时间复杂度为 ，也即 。所以对于  个长度为  的数组，总代价为：

此时，递归树高为 ，除最后一层外其余层的代价为 ；最后一层代价为 。故，合并子表的总代价为：

故  ；当   时，  相对   被忽略；故   的最大值为  。

选择插入排序比合并排序快的最大列表长度。

证明 BUBBLESORT 的正确性，除了证明不等式（2.3），还需要证明 A′ 中的元素全部来自于 A。

内循环-循环不变式 ：for 循环每次迭代开始，子数组 A[j..A.length] 中第 j 个元素是最小的，即 A[j] <= A[k], k > j；同时元素 A[j..A.length] 是原来在位置 j 到 A.length的元素，但是已经挑选出最小元素的。

初始化 ： 第一次循环迭代之前（当 j = A.length 时），循环不变式成立。因为此时循环不变式中只有一个元素，也是最小元素。

保持 ： 假设此次迭代之前，有循环不变式 A[j..A.length] 为真。则再次进入循环体，我们检查 A[j], A[j − 1] 的大小，并保持了 j − 1 位置为 A[j], A[j − 1] 中最小的一个。由于已经有 A[j] 为 A[j..A.length] 中最小的元素了，所以 A[j − 1] 也应为 A[j − 1..A.length] 中最小的元素。此时子数组 A[j - 1..A.length] 是由原来 A[j - 1..A.length] 中的元素组成的。那么 for 循环这次迭代增加位于 j - 1 的元素保持了循环不变式。

终止 ： 循环终止时，j = i + 1。也就是 A[i..A.length] 是由原来 A[i..A.length] 元素组成，但已经挑选出最小的元素，且最小元素为 A[i]。

外循环-循环不变式： for 循环每次迭代开始，A[1..i − 1] 构成升序数组，且剩余子数组 A[i..A.length] 中的元素都大于等于 A[i − 1]。

初始化 ： 第一次循环迭代之前（当 i = 1 时），此时数组 A[1..i - 1] 为空数组，故循环不变式成立。

保持 ： 假设第 i 次迭代之前，循环不变式成立，即 A[1..i−1] 已排好序，且剩余子数组 A[i..A.lenght] 中的元素都大于等于 A[i - 1]。则再次进入循环体，根据 b 可得，A[i..A.length] 是由原来 A[i..A.length] 元素组成，但已经挑选出最小的元素，且最小元素为 A[i]。故 A[1..i] 也已升序排好，且 A[i + 1..A.length] 中的元素均大于 A[i]。

终止 ： 循环终止时，i = A.length - 1。也就是 A[1..A.length - 1] 已升序，且 A[A.length] 大于 A[1..A.length - 1] 中的任意一个元素；所以 A[1..A.length] 已排好升序。

最坏情况运行时间和插入排序一样，都是 。

但是插入排序最好情况运行时间为 ，即只执行 n - 1 次比较；冒泡排序的比较次数则没有减少，故时间复杂度仍为 。

同时，若使用数组数据结构，则冒泡排序与插入排序的交换操作数量一致，均为逆序对数；但若使用链表数据结构的话，其交换操作会比插入操作数量多很多。

故，冒泡排序所需的平均运行时间比插入排序多的多。

运行时间为： 。比霍纳规则相比要慢。

可以优化一下：

。与霍纳规则相同。

        

初始化 ：在第一次迭代之前， i = n，y = 0，满足条件。

保持 ：第 i 次迭代， 。

终止 ：i = -1，则  ，满足题意。

可根据 c 中循环不变式的终止段，得出该结论。

{2, 1}, {3, 1}, {8, 6}, {8, 1}, {6, 1}

降序集合 {n, n - 1, ..., 1} 具有最多的逆序对。逆序对数量： 。

逆序对数量即为 while 循环内的交换操作数量。也就是有多少个逆序对，就要执行多少次 while 内循环。所以，含有逆序对的数组排序时间为 ，其中 d 为数组中含有逆序对的数量。

㈣ Data Structures and Algorithm Analysis in C++书后的习题答案

下面是我根据别人的提示和自己的参考总结出的几个阶段的书籍，希望对你有帮助！！

第一阶段：
1：：H.M.Deitel和P.J.Deitel的《 C++ How to Program 》（C++大学教程）
2：： 钱能的《C++程序设计教程》
3：：Stanley B.lippman着 侯捷 译的《essential c++》
4：：Stanley B.Lippman,Josee LaJoie,Barbara E.Moo的《c++ primer》
5：：Bjarne Stroustrup的《the c++ programming language》

第二阶段：
1：：Scott Meyers的《effective c++》
2：：Herb Sutter的《exceptional c++》
3：：Scott Meyers的《more effective c++》
4：：Herb Sutter的《more exceptional c++》

第三阶段：
1：：Stanley B.lippman的《insied the c++ object model》（深度探索C++ 对象模型）
2：：Bjarne Stroustrup的《The design and evolution of c++》（C++的设 计与演化）
3：：tephen C. Dewhurst的《C++ Gotchas: Avoiding Common Problems in Coding and Design》（C++程序设计陷阱）

第四阶段：
1：： Nicolai M.Josuttis的《the c++ standard library》（C++标准程序库 —自修教程与参考手册）
2：：Scott Meyers的《effective stl》
3：：Matthew H. Austern的《generic programming and the stl》（泛型编 程与STL)
4：：侯捷的 《stl源码剖析》

第五阶段：
1：：Herb Sutter的《exeptional c++ style》
2：：《c++ template》
3：：Andrei Alexandrescu的《modern c++ design》

第六阶段
1：：《C++ 输入输出流及本地化》《C++ Network Programming》《大规模C++程序设计》
2：：Barbara E.Moo和Andrew Koenig的《Ruminations On C++》(C++ 沉思录)

其他的：
Stanley B. Lippman,《Inside The C++ Object Model》影印版、中文版《深度探索C++对象模型》
Elements of Reusable Object-Oriented software》影印版、中文版《设计模式：可复用面向对象软件的基础》
John Lakos的着作《Large-Scale C++ Software Design》（《大规模C++程序设计》
Andrew Koenig和Barbara Moo在《Accelerated C++: Practical Programming by Example》《Ruminations on C++》
Bruce Eckel,《C++编程思想》

windows编程系列：

Charles Petzold 的 《Programming Windows》（Windows程序设计）
Jeffrey Richter 的《》（Windows核心编程）和《Advanced Windows》（Windows 高级编程指南）

数据结构和算法
1：：清华教授严蔚敏和广东工业大学教授吴伟民的《数据结构(C语言版)》
2：：清华教授殷人昆的《数据结构(用面向对象方法与C++描述）》
3：：经典书籍：Mark Allen Weiss的《Data Structures and Algorithm Analysis in C》（数据结构与算法分析--C语言描述）和《Data Structures and Algorithm Analysis in C++》（数据结构与算法分析--C++语言描述）
4：：王晓东的《算法设计与分析》
5：：M.H.Alsuwaiyel（沙特）的 《Algorithms Design Techniques and Analysis》（算法设计技巧与分析）
6：：经典：Thomas H.Cormen, Charles E.Leiserson的《Introction to Algorithms》（算法导论）
另外,虚机团上产品团购,超级便宜

㈤ 《算法导论》三种解递归式的方法

代入法可以用来确定一个递归式的上界或下界。这种方法很有效，但只能用于解的形式很容易猜的情形。

例如，我们需要确定下面递归式的上界：

该递归式与归并排序相似，我们可以猜测其解为

代入法要求证明，恰当选择常数 c>0，可有 T(n)≤cn lgn。首先假设此上界对所有正数 m<n 都成立，特别是对于 m=n/2，有 T(n/2)≤c(n/2)lg(n/2)。将其代入递归式，得到：

其中，只要 c≥1，最后一步都会成立。

并不存在通用的方法来猜测递归式的正确解，但总有一些试探法可以帮助做出好的猜测：

如果某个递归式与先前见过的类似，则可猜测该递归式有类似的解。如，递归式

看起来比较难解，因为右式 T 的自变量中加了 17，但我们可以猜测这个多出来的项对解的影响不大，因为当 n 很大时， 与 之间的差别并不大，两者都将 n 分成均匀的两半。

另一种方法是先证明递归式的较松的上下界，然后再缩小不确定性区间。例如，对递归式 ，因为递归式中有 n，而我们可以证明初始上界为 。然后，逐步降低其上界，提高其下界，直到达到正确的渐近确界 。

有时，我们或许能够猜出递归式解的渐近界，但却会在归纳证明时出现一些问题。通常，问题出在归纳假设不够强，无法证明其准确的界，遇到这种情况时，可以去掉一个低阶项来修改所猜测的界，以使证明顺利进行。如下面的递归式：

可以猜测其解为 ，即要证明对适当选择的 c，有 。有所猜测的界对递归式做替换，得到

由此无法得到 ，无论 c 的值如何。如果猜测一个更大的界，如 ，虽然这确实是上界，但事实上，所猜测的解 却是正确的。为了证明这一点，要做一个更强的归纳假设。

从直觉上说，猜测 几乎是正确的，只是差了一个常数 1，即一个低阶项，然而，就因为差了一项，数学归纳法就无法证明出期望的结果。从所作的猜测中减去一个低阶项，即 是个常数。现在有

只要 b≥ 1。这里，c 要选的足够大，以便能处理边界条件。

你可能会觉得从所作的猜测中减去一项有点儿与直觉不符。为什么不是增加一项来解决问题呢？关键在于要理解我们是在用数学归纳法：通过对更小的值作更强的假设，就可以证明对某个给定值的更强的结论。

在运用渐近表示时很容易出错。例如，对递归式 ，由假设 ，并证明

就是错误的，因为 c 是常数，因而错误地证明了 。错误在于没有证明归纳假设的准确形式，即 。

有时，对一个陌生的递归式作一些简单的代数变换，就会使之变成读者较熟悉的形式。如下例子：

这个式子看上去比较难，但可以对它进行简化，方法是改动变量。为了方便起见，不考虑数的截取整数问题，如将 化为整数。设 ，得

再设 ，得到新的递归式

这个式子看起来与 就非常像了，这个新的递归式的界是： 。将 带回 ，有 。

有时候，画出一个递归树是一种得到好猜测的直接方法。在递归树中，每一个节点都代表递归函数调用集合中一个子问题的代价。将树中每一层内的代价相加得到一个每层代价的集合，再将每层的代价相加，得到的结果是所有层次的总代价。当用递归式表示分治算法的运行时间时，递归树的方法尤其有用。

递归树最适合用来产生好的猜测，然后用代入法加以验证。但使用递归树产生好的猜测时，通常可以容忍小量的“不良量”，因为稍后就会证明所做的猜测。如果画递归树时非常地仔细，并且将代价都加了起来，那么就可以直接用递归树作为递归式的解的证明。

在讲述例子之前，我们先来看一个几何级数公式

对于实数 x≠1，式

是一个几何级数（或称指数级数），其值为

当和是无限的且 |x|<1 时，有无限递减几何级数

我们以递归式

为例来看一下如何用递归树生成一个好的猜测。首先关注如何寻找解的一个上界，因为我们知道舍入对求解递归式通常没有影响（此处即是我们需要忍受不精确的一个例子），因此可以为递归式

创建一颗递归树，其中已将渐近符号改写为隐含的常数系数 c>0。

构造的递归树如下：

求所有层次的代价之和，确定整棵树的代价：

最后的这个公式看起来不够整洁，但我们可以再次充分利用一定程度的不精确，并利用无限递减几何级数作为上界。回退一步，得到：

此时，我们得到了递归式的一个猜测，在上面的例子里， 系数形成了一个递减的等比级数，可知这些系数的总和的上界是常数 。由于树根所需的代价为 ，所以根部的代价占总代价的一个常数部分。换句话说，整棵树的总代价是由根部的代价所决定的。

事实上，如果 确实是此递归式的上界，那么它一定是确界，为什么呢？第一个递归调用所需要的代价是 ，所以 一定是此递归式的下界。

现在我们可以使用代换法来验证猜测的正确性， 是递归式 的一个上界。只需要证明，当某常数 d>0， 成立。适用与前面相同的常数 c>0，有

只要 d≥ ，最后一步都会成立。

上图是递归式

对应的递归树。我们还是使用 c 来代表 项常数因子。当将递归树内各层的数值加起来时，可以得到每一层的 cn 值。从根部到叶子的最长路径是 。因为当 时， ，所以树的深度是 。

直觉上，我们预期递归式的解至多是层数乘以每层的代价，也就是 。总代价被均匀地分布到递归树内的每一层上。这里还有一个复杂点：我们还没有考虑叶子的代价。如果这棵树是高度为 的完整二叉树，那么有 个叶子节点。由于叶子代价是常数，因此所有叶子代价的总和为 ，或者说 。然而，这棵递归树并不是完整的二叉树，少于 个叶子，而且从树根往下的过程中，越来越多的内部结点在消失。因此，并不是所有层次都刚好需要 cn 代价；越靠近底层，需要的代价越少。我们可以计算出准确的总代价，但记住我们只是想要找出一个猜测来使用到代入法中。让我们容忍这些误差，而来证明上界为 的猜测是正确的。

事实上，可以用代入法来证明 是递归式解的上界。下面证明 ，当 d 是一个合适的正值常数，则

上式成立的条件是 。因此，没有必要去更准确地计算递归树中的代价。

主方法给出了求解递归式的“食谱”方法，即将规模为 n 的问题划分为 a 个子问题的算法的运行时间，每个子问题规模为 ，a 和 b 是正常数。a 个子问题被分别递归地解决，时间各为 。划分原问题和合并答案的代价由函数 描述。

从技术正确性角度来看，递归式实际上没有得到很好的定义，因为 可能不是一个整数。但用 向上取整或向下取整来代替 a 项 并不影响递归式的渐近行为，因而，在写分治算法时略去向下取整和向上取整函数会带给很大的方便。

其中我们将 n/b 解释为 n 除以 b 的向下取整或向上取整。那么 T(n) 有如下渐近界：

在使用主定理之前，我们需要花一点时间尝试理解它的含义。对于三种情况的每一种，将函数 f(n) 与函数 进行比较。直觉上，两个函数较大者决定了递归式的解。若函数 更大，如情况 1，则解为 T(n)= ( )。若函数 f(n) 更大，如情况 3，则解为 T(n)= (f(n))。若两个函数大小相当，如情况 2，则乘上一个对数因子，解为 T(n)= ( )= ( )。

另外还有一些技术问题需要加以理解。在第一种情况下，不仅要有 小于 ，还必须是多项式地小于，也就是说， 必须渐近小于 ，要相差一个因子 ，其中 是大于 0 的常数。在第三种情况下，不是 大于 就够了，而是要多项式意义上的大于，而且还要满足“正则”条件 。

注意：三种情况并没有覆盖所有可能的 f(n)。当 f(n) 只是小于 但不是多项式地小于时，在第一种情况和第二种情况之间就存在一条“沟”。类似情况下，当 f(n) 大于 ，但不是多项式地大于时，第二种情况和第三种情况之间就会存在一条“沟”。如果 f(n) 落在任一条“沟”中，或是第三种情况种规则性条件不成立，则主方法就不能用于解递归式。

使用主方法很简单，首先确定主定理的哪种情况成立，即可得到解。

例如：

对于这个递归式，我们有 a=9，b=3，f(n)=n，因此 = = 。由于 f(n) = ，其中 ， 因此可以应用于主定理的情况 1，从而得到解 T(n) = Θ( ) 。

现在考虑

其中，a = 1， b = 3/2， f(n) = 1，因此 = = = 1 。由于 f(n) = = Θ(1) ，因此可应用于情况2，从而得到解 T(n) = Θ( ) 。

对于递归式

我们有 a = 3，b = 4，f(n) = nlgn，因此 = =O( )。由于 当 n，其中 ，因此，如果可以证明正则条件成立，即应用于情况 3。当 n 足够大时，对于 ， ，因此，由情况 3，递归式的解为 T(n)= ( )。

主方法不能用于如下递归式：

虽然这个递归式看起来有恰当的形式：a=2，b=2， ，以及 。你可能错误地认为应该应用情况 3，因为 渐近大于 。问题出现在它并不是多项式意义上的大于。对任意正常数 ，比值 都渐近小于 。因此，递归式落入了情况 2 和情况 3 之间的间隙。

证明分为两部分。第一部分分析“主”递归式 ，并作了简化假设 仅定义在 b>1 的整数幂上，即 ， ， ，…。这部分从直觉上说明该定理为什么是正确的。第二部分说明如何将分析扩展至对所有的正整数 n 都成立，主要是应用数学技巧来解决向下取整函数和向上取整函数的处理问题。

取正合幂时的证明

对于递归式

此时的假设是 n 为 b>1 的正合幂，且 b 不必是整数。分析可分成三个引理说明，第一个引理是将解原递归式的问题归约为对一个含和式的求值的问题。第二个引理决定含和式的界，第三个引理把前两个合在一起，证明当 n 为 b 的正合幂时主定理成立。

引理一 ：设 a≥1，b>1 为常数，f(n) 为定义在 b 的正合幂上的非负函数。定义 如下：

其中 i 是正整数，则有

证明：如下图。根节点代价为 f(n)，它有 a 个子女，每个代价是 。（为方便起见可将 a 视为整数，但这对数学推导没什么影响。）每个子女又各有 a 个子女，代价为 。这样就有 个结点离根的距离为 2。一般地，距根为 j 的结点有 个，每一个的代价为 。每一个叶结点的代价为 ，每一个都距根 ，因为 。树中共有 个叶结点。

可以将树中各层上的代价加起来而得到方程 ，第 j 层上内部结点的代价为 ，故各层内部结点的总代价和为

在其所基于的分治算法中，这个和值表示了将问题分解成为子问题并将子问题的解合并时所花的代价，所有叶子的代价（即解 个规模为 1 的子问题的代价）为 。

根据递归树，主定理的三种情况对应于树中总代价的三种情况：1、由所有叶子节点的代价决定；2、均匀分布在各层上；3、由根结点的代价决定。

引理二 ：设 a≥1，b≥1 为常数， 为定义在 b 的整数幂上的非负函数。函数 由下式定义

对 b 的整数幂，该函数可被渐近限界为：

证明：对情况 1，有 ，这隐含着 。用它对方程 做代换，得

对 O 标记内的式子限界，方法是提出不变项并作简化，得到一个上升几何级数：

因为 b 与 都是常数，最后的表达式可化简为 。用此表达式对 作替换，得

情况 1 得以验证。

为证情况 2，假设 ，有 。用此式对方程 作替换，得

对 记号中的式子做类似情况 1 中的限界，但所得并非是几何级数，而是每项都是相同的:

用此方程对 中的和式做替换，有

则情况 2 得以验证。情况 3 也可以用类似的方式证明。

引理三 ：设 a≥1，b>1 是常量， 是定义在 b 的整数幂上的非负函数。定义 T(n) 如下：

其中 i 是正整数。对于 b 的整数幂，T(n) 可有如下渐近界：

证明：用引理二给出的界来对引理一中的式 求值。对情况 1 有

对情况 2 有

对情况 3 有

㈥ [算法导论]根据渐近增长率排序

参考网上的一篇博客，经过整理汇总成下面这个表，请参考指正。

㈦ 《算法导论》第三章-思考题（参考答案）

（多项式的渐进行为） 假设 是一个关于 的 次多项式，其中 ， 是一个常量。使用渐进符号的定义来证明下面的性质。

a. 若 ，则 。

b. 若 ，则 。

c. 若 ，则 。

d. 若 ，则 。

e. 若 ，则 。

已知： ，易得 。

故 。

情况 1：

，即： 。

故 。

情况 2：

，即： 。

故 。

情况 3：

，即： 。

故 。

情况 4：

，即： 。

故 。

情况 5：

，即： 。

故 。

（相对渐进增长） 为下表中的每对表达式 指出 是否是 的 或 。假设 且 均为常量。回答应以表格的形式，将“是”或“否”写在每个空格中。

a.

令 代替 ，并令 代替 a，可得：

即： 。

又：若 。故： 。

b.

故， 。

令 。故 。

c.

。又 的值为在区间 中波动，故 与 无任何关系

d.

严格递增，故对于任意正常量 ，总存在 ，使得 ，即：

也易证：故对于任意正常量 ，总存在 ，使得 ，即：

e.

。故 。

f.

故，

又， 是严格递增的函数。故，

故， ，也即

也即

（根据渐进增长率排序）

a. 根据增长的阶来排序下面的函数，即求出满足 的函数的一种排列 。把你的表划分成等价类，使得函数 和 在相同类中当且仅当 。

b.给出非负函数 的一个例子，使得对所有在（a）部分中的函数 ， 既不是 也不是 。

（渐进记号的性质） 假设 和 为渐进正函数。证明或反驳下面的每个猜测。

a. 蕴含 。

错。例如： 。

b. 。

错。例如： 。

c. 蕴含 ，其中对所有足够大的 ，有 且 。

正确。

对于足够大的 ，有 ；且 ，则存在正常量 ，使得 ，有

​

​

又 ，故当 ，且 足够大，有：

​

故原问题成立。

d. 蕴含 。

错。例如： 。

e. 。

当 时， ；其他条件下，不成立。

f. 蕴含 。

正确。 ，即存在正常量 ，使得 ，有

​ ，即

令 ，得 。

g. 。

错。例如： 。

h. 。

正确。

易得， ，即存在正常量 ，使得 ，都有 。

令 ，即存在正常量 ，使得 ，都有 。

令 ，则 ，有 。

即 。

（ 与 的一些变形） 某些作者用一种与我们稍微不同的方式来定义 ；假设我们使用 （读作“ 无穷”）来标识这种可选的定义。若存在正常量 ，使得对无穷多个整数 ，有 ，则称 。

a. 证明：对渐进非负的任意两个函数 和 ，或者 或者 或者二者均成立，然而，如果使用 来代替 ，那么该命题并不为真。

主要缺少了 这个条件；则若 ，必然有无穷多个正整数 ，使得 成立；

若 ，则上述两者均成立；

反例： ，但 。

b. 描述用 代替 来刻画程序运行时间的潜在优点与缺点。

优点： 对下届的要求更宽松，可以兼容更多的情况；

缺点： 并非严格的渐进下界。因此实际意义并不大。

​ 某些作者也用一种稍微不同的方式来定义 ；假设使用 来标识这种可选的定义。我们称 当且仅当 。

c. 如果使用 代替 但仍然使用 ，定理 3.1 中的“当且仅当”的每个方向将出现什么情况？

没有变化。 成立意味着 渐进非负，故 。

​ 有些作者定义 （读作“软 ”）来意指忽略对数因子的 ：

：存在正常量 和 ，使得对所有 ，有 。

d. 用一种类似的方式定义 和 。证明与定理 3.1 相对应的类似结论。

：存在正常量 和 ，使得对所有 ，有 。

：存在正常量 和 ，使得对所有 ，有 。

（多重函数） 我们可以把用于函数 中的多重操作符 * 应用于实数集上的任意单调递增函数 。对给定的常量 ，我们定义多重函数 为

​

该函数不必再所有情况下都是良定义的。换句话说，值 是为缩小其参数到 或更小所需函数 重复应用的数目。

​ 对如下每个函数 和常量 ，给出 的一个尽量紧确的界。

㈧ 为什么《算法导论》中的数组序号是从1开始的

c语言下标从零开始是个错误，并且 index 也是一个有误导性的名词，它表示的是偏移量，明明应该用 offset。
然后 c 的徒子徒孙都学了它，导致现在很多人都误以为下标应该从 0 开始。
早期蛮荒时代，很多东西都不科学，算法导论作者致力于与落后文明作斗争，然而却遭到了楼主你的不理解，实乃编程届一大憾事。
我再说一遍，C 是结构化的汇编，下标基 0 是受到了 PDP-11 指令集的影响，更老的语言（比如 Fortran）都是基 1 的。
另外用 0/非 0 代表 false/true 也是 PDP-11 中 TST 指令和 Z 位的行为。
可能是这本书强调算法的求学思想，所以从一更加符合数学的数组规定。
但是编程的时候，指针这个东西会经常用到，如果用a(o)作为第一个元素 那么*a+n就等同于a(n) 比较方便
算法导论上的这个问题呢，我觉得我比较同意楼上的看法，这个书上面的很多的程序并不是可以敲上去直接运行的，他只是伪代码，思想而已，给人看的，人类的普遍思维是从1开始，那么书页就是从1开始了
说编程语言是给机器看而伪代码是给人看的简直是逗大家笑吧...编程语言设计出来就是给人看的....
另外从0开始在很多方便都极好....我觉得写多代码都能体会到吧..
帮算导洗地：
算法导论通篇用的是伪代码 是给人类阅读理解的 不是设计给机器去运行的
而绝大多数情况下， index 从 1 开始更符合人类直觉（如果你对这点有异议请参考的答案 ）
但少数情况下， index 从 0 开始更符合人类直觉。例如书中 hashing 还有 FFT 那块内容， index 是从 0 开始的。
其实写几天 Pascal 你就适应啦。。