本文共 29688 字，大约阅读时间需要 98 分钟。

Part I. Foundations
Chapter 2. Getting Started

2.1 插入排序（Insertion sort）

输入： 大小为 $n$ 的数字序列 $⟨a_1,a_2,\dots ,a_n⟩$。
输出： 输入序列的重新排序 $⟨a_1^{{}^{\prime }},a_2^{{}^{\prime }},\dots ,a_n^{{}^{\prime }}⟩$，满足条件 $a_1^{{}^{\prime }}\le a_2^{{}^{\prime }}\le \cdots \le a_n^{{}^{\prime }}$。

将要进行排序的序列中的数字可称为键（key）。

区分伪代码（pseudocode）与真实代码：
① 在伪代码中，我们采用最清晰、最简洁的表达方式来描述给定算法。有时会直接使用短语或句子。
② 伪代码通常不会涉及软件工程的问题。为了更简洁地传达算法的本质，通常会忽略数据抽象、模块化、错误处理等问题。

插入排序是一种对少量元素进行排序的有效算法。插入排序的工作机制，与许多人玩牌时对手上扑克牌的排序类似。开始时，左手空着，牌面朝下放在桌子上。接着，一次从桌上取出一张卡，将其插入左手的正确位置。在任何时候，左手拿着的牌都是排序好的。

INSERTION-SORT($A$)
1 for $j=2$ to $A.length$
2   $key=A[j]$
3   // Insert $A[j]$ into the sorted sequence $A[1..j-1]$.
4   $i=j-1$
5   while $i>0$ and $A[i]>key$
6     $A[i+1]=A[i]$
7     $i=i-1$
8   $A[i+1]=key$

根据上面的伪代码，C++ 代码如下：

void InsertionSort(vector<int>& A){   	for(int j=1; j<A.size(); ++j)	{   		int key = A[j];		int i = j - 1;		while(i>=0 && A[i]>key)		{   			A[i+1] = A[i];			--i;		}		A[i+1] = key;	}}

循环不变式（loop invariant）与插入排序的正确性

我们将 $A[1..j-1]$ 的特性声明为循环不变式：在第 1–8 行的 for 循环的每次迭代开始时，子数组 $A[1..j-1]$ 由最初在 $A[1..j-1]$ 中的元素组成，但，是按顺序排序好的。

我们使用循环不变式来验证算法的正确性。下面介绍关于循环不变式的 3 个要点：
初始： 在循环的第一次迭代之前，循环不变式为真。
保持： 如果在循环的一次迭代之前为真，那么在下一次迭代之前保持为真。
终止： 当循环终止时，不变式为我们提供了有用的性质，这种性质有助于验证算法是正确的。

上述内容前两个性质与数学归纳法（mathematical induction）相似。 终止性质不同于我们通常使用数学归纳法的方式，在数学归纳法中，我们无限地应用归纳步骤。 在这里，当循环终止时，我们停止“归纳”。

伪代码约定（Pseudocode conventions）

• 缩进表示块结构。例，上述的 for 语句、while 语句等下面的缩进。
• 循环结构 while、for 和 repeat-until，条件结构 if-else 这两者的解释类似于 C，C++，Java，Python 和 Pascal。
• 符号 “//” 表示该行后面余下的部分是注释。
• 形式如 $i=j=e$ 的多重赋值，将表达式 $e$ 的值赋值给变量 $i$ 和 $j$。等价于 $j=e$，$i=j$。
• 变量（如$i$，$j$ 和 $key$）是给定程序的局部变量。没有明确指出，不使用全局变量。
• 我们通过指定数组名称和方括号中的索引来访问数组元素，如 $A[i]$。记号“$..$”用于表示数组中的值范围，如 $A[1..j]$。
• 我们通常将复合数据组织到由属性（attribute）组成的对象（object）中。我们使用面向对象的编程语言中的语法访问特定的属性：对象名称，后跟一个点，然后是属性名。例，$A.length$。
  我们将代表数组或对象的变量视为，指向代表数组或对象的数据的指针。对于对象 $x$ 的所有属性 $f$，设置 $y=x$ 会使 $y.f$ 等于 $x.f$。即，在赋值 $y=x$ 之后，$x$ 和 $y$ 指向同一对象。
  我们的属性表示法可以是“级联”的。例如，如果我们赋值 $y=x.f$，则 $x.f.g$ 与 $y.g$ 相同。
  有时，指针根本不会指向任何对象。在这种情况下，我们给它一个特殊值 NIL。
• 我们将参数传递给过程，按值（by value）传递。传递对象时，将复制指向代表该对象的数据的指针，传递对象的属性时，不这样。同样，数组是通过指针传递的。
• return 语句将控制权转移回调用过程中的调用点。伪代码允许在单个 return 语句中返回多个值。
• 布尔运算符 “and” 和 “or” 存在短路（short circuiting）运算现象。
• 关键字 error 表示出错，因为被调用的过程的条件错误。调用过程负责处理错误，我们不需要指定措施。

练习

2.1-1 以图2.2为样例，说明数组 $A=⟨31,41,59,26,41,58⟩$ 上的 INSERTION-SORT 操作。
解： 第1步：31，41，59，26，41，58
第2步：31，41，59，26，41，58
第3步：26，31，41，59，41，58
第4步：26，31，41，41，59，58
第5步：26，31，41，41，58，59

2.1-2 重写 INSERTION-SORT 过程，以非递增而不是非递减的顺序进行排序。
解： 将第 5 行的 while $i>0$ and $A[i]>key$ 改为 while $i>0$ and $A[i]<key$，其余不变。

2.1-3 考虑查找问题（searching problem）：
输入： 大小为 $n$ 的序列 $A=⟨a_1,a_2,\dots ,a_n⟩$ 和一个值 $v$。
输出： 使 $v=A[i]$ 成立的索引 $i$，或者特殊值 NIL（如果 $v$ 不在 $A$ 中）。
写出用于线性查找（linear search）的伪代码，扫描整个序列查找 $v$。使用循环不变式证明你的算法的正确性。确保你的循环不变式满足 3 个必要的性质。
解： LINEAR-SEARCH($A$, $v$)
1 for $i=1$ to $A.length$
2   if $v==A[i]$
3     return $i$
4 return NIL
证明：循环不变式为：$A[1..i-1]$ 不包含 $v$。
初始： 在循环第一次迭代之前，$i=1$，则 $A[1..i-1]$ 为空，不包含 $v$，循环不变式为真。
保持： 当 $v$ 不等于 $A[i]$ 时，则 $A[1..i]$ 不包含 $v$，在循环的下一次迭代前，循环不变式为真；当 $v$ 等于 $A[i]$ 时，循环终止。
终止： 当 $v$ 等于 $A[i]$ 或 $i=A.length+1$（即 $A=n+1$）时，循环终止。当 $v$ 等于 $A[i]$ 时，条件 $v=A[i]$ 成立，返回 $i$。当 $i=n+1$ 时，$A[1..n]$ 不包含 $v$，返回 NIL。
所以，算法正确。

2.1-4 考虑问题：将两个 $n$ 位二进制整数相加，这两个整数存储在两个 $n$ 位元素数组 $A$ 和 $B$ 中。两个整数之和应以二进制形式存储在 $n+1$ 位元素数组 $C$ 中。正式表述问题，写出用于将两个整数相加的伪代码。
解： 正式表述问题如下：
输入： 二进制整数 $a$ 的表示形式为 $a_n\dots a_2{a}_1$，存储在大小为 $n$ 的数组 $A=⟨a_1,a_2,\dots ,a_n⟩$，二进制整数 $b$ 的表示形式为 $b_n\dots b_2{b}_1$，存储在大小为 $n$ 的数组 $B=⟨b_1,b_2,\dots ,b_n⟩$。
输出： 大小为 $n+1$ 的数组 $C=⟨c_1,c_2,\dots ,c_n,c_{n+1}⟩$，满足条件 $c=a+b$，其中，二进制整数 $c$ 的表示形式为 $c_{n+1}{c}_n\dots c_2{c}_1$。
伪代码如下：
ADD-BINARY-INTEGERS($A$, $B$)
1 $n=A.length$
2 $C=[1..n+1]$
3 $carry=0$
4 for $i=1$ to $n$
5   $num=A[i]+B[i]+carry$
6   $C[i]=num\%2$
7   $carry=num/2$
8 $C[n+1]=carry$
9 return $C$

2.2 分析算法（Analyzing algorithms）

分析算法意味着预估算法所需的资源。有时，诸如内存、通信带宽或计算机硬件之类的资源是最主要的问题，但是最常见需要测量的资源是计算时间。
在分析算法之前，我们必须具有相关的实现技术的模型，包括技术所需的资源和代价的模型。本书主要将一种通用单处理器、随机存取机器（RAM: random-access machine ）计算模型作为实现技术，通过计算机程序实现我们的算法。在 RAM 模型中，指令是一个接一个地执行的，没有并发操作。
① RAM 模型包含实际计算机中常见的指令：算术指令（加，减，乘，除，取余，向下取整 (floor)，向上取整(ceiling)），数据移动指令（加载，存储，复制）和控制指令（条件和非条件转移，子程序调用与返回）。每条这样的指令花费常量的时间。
② RAM 模型中的数据类型为整数和浮点数（用于存储实数）。假设数据的每个字（word）的大小有限制。
③ 在 RAM 模型中，我们不对现代计算机中常见的存储器层次进行建模。即不对高速缓存或虚拟内存建模。
④ RAM 模型分析通常能够很好地预测实际计算机上的性能。

插入排序算法的分析

INSERTION-SORT 过程时间开销与输入有关：序列的长度、序列已排序的程度等。通常，算法的时间开销随着输入规模的增加而增加，因此习惯上将程序的运行时间表示为输入规模的函数。
输入规模（input size）的概念取决于正在研究的问题。例如：
① 排序或计算离散傅立叶变换，最自然的度量是输入的元素个数（number of items in the input）。
② 两个整数相乘，最佳度量是用普通二进制表示法表示的输入数字的总位数（total number of bits）。
③ 有时，用两个数来表示输入规模更合适。如，算法输入是图形，可以通过图中的顶点数和边数来表示。
对于正在研究的每个问题，我们需要指出输入规模的度量标准。
算法的运行时间（running time）是指，在特定输入时执行的基本操作数或“步骤”的数量。
定义“步骤”的概念应尽可能独立于机器。采用以下观点：执行伪代码的每一行需要固定的时间；假定每次执行第 $i$ 行伪代码都花费时间 $c_i$，其中 $c_i$ 是一个常数。 这种观点与 RAM 模型是一致的，并且反映了伪代码在大部分实际计算机上是如何实现的。

设 $t_j$ 为第 5 行中 while 循环执行的测试次数。计算 INSERTION-SORT 过程总运行时间 $T(n)$：
$$T(n)=c_{1}n+c_2(n-1)+c_4(n-1)+c_5\sum _{j=2}^n{t}_j+c_6\sum _{j=2}^n(t_j-1)+c_7\sum _{j=2}^n(t_j-1)+c_8(n-1)$$

若输入数组是排序好的，则对于 $j$ 的每个值，在第 5 行，$i=j-1$ 时，都有 $A[i]⩽key$。此时，最佳运行时间可以表示为 $an+b$，常量 $a$ 和 $b$ 依赖于 $c_i$。这是 $n$ 的一个线性函数（linear function）。
若输入数组是逆序排序的。此时，最坏运行时间可以表示为 $a{n}^2+bn+c$，常量 $a$、$b$ 和 $c$ 依赖于 $c_i$。这是一个关于 $n$ 的二次函数（quadratic function）。

最坏情况与平均情况分析

在本书中，我们一般考虑算法的最坏情况运行时间（worst-case running time）。理由如下：
① 算法的最坏情况运行时间为我们提供了在任何输入下运行时间的上限。
② 对于某些算法来说，最坏情况出现相当频繁。
③ 通常，“平均情况”与最坏情况大致一样差。
在某些特定情况下，我们对算法的平均情况（average-case）运行时间感兴趣。在本书中，我们将看到概率分析（probabilistic analysis）技术应用于各种算法。我们有时可以使用随机算法（randomized algorithm），该算法可以作出随机的选择，以进行概率分析并生成预期的（expected）运行时间。

增长量级

我们已经使用了一些简化抽象来简化对 INSERTION-SORT 过程的分析。现在进一步简化抽象：真正使我们感兴趣的使运行时间的增长率（rate of growth），或称为增长量级（order of growth）。
对于插入排序，当我们忽略低阶项和前导项的常数系数时，只剩下前导项的 $n^2$ 因子。我们记插入排序的最坏情况下的运行时间为 $\Theta (n^2)$（发音：“theta of n-squared”）。

练习

2.2-1 用 $\Theta$ 形式表示函数 $n^3/1000-100n^2-100n+3$。
解： $\Theta (n^3)$

2.2-2 考虑对数组 $A$ 中的 $n$ 个数进行排序：在 $A$ 中找出最小的元素，将它与 $A[1]$ 中的元素交换。接着，找出 $A$ 中的第二小的元素，将它与 $A[2]$ 中的元素交换。对 $A$ 中的前 $n-1$ 个元素继续这一过程。写出此算法的伪代码，该算法称为选择排序（selection sort）。此算法的循环不变式是什么？为什么只需在前 $n-1$ 个元素上运行，而不是在所有 $n$ 个元素上运行？给出选择算法的最佳情况和最坏情况的运行时间，以 $\Theta$ 形式写出。
解： SELECTION-SORT($A$)
1 for $i=1$ to $(A.length-1)$
2  $minIndex=i$
3  for $j=i+1$ to $A.length$
4   if $A[j]<A[minIndex]$
5    $minIndex=j$
6  exchange $A[i]$ with $A[minIndex]$
该算法的循环不变式为：$A[1..i]$ 是从小到大排序好的。
因为 $A[1..n-1]$ 是从小到大排序好的，且 $A[1..n-1]$ 中的所有元素都不大于 $A[n]$ 中的元素，所以 $A[1..n]$ 是从小到大排序好的。所以只需在前 $n-1$ 个元素上运行。
算法的最佳情况运行时间：$\Theta (n^2)$
算法的最坏情况运行时间：$\Theta (n^2)$

2.2-3 再次考虑线性查找算法（见练习 2.1-3）。假设待查找的元素是数组中任一元素的可能性是相等的，在平均情况下，输入序列中有多少个元素需要检查？在最坏情况下呢？用 $\Theta$ 形式表示，线性查找在平均情况和最坏情况的运行时间是怎样的？对你的答案加以说明。
解： 假设数组有 $n$ 个元素。
在平均情况下，检查 $i$ 次（$i$ 取值为：$1,2,\dots ,n$）的可能性均为 $1/n$。则需要检查的元素个数为：
$1\times (1/n)+2\times (1/n)+\cdots +n\times (1/n)=(n+1)/2$
即，在平均情况下，检查 $(n+1)/2$ 个元素。运行时间为 $\Theta (n)$。
在最坏情况下，待查找的元素在数组的第 $n$ 个位置上，需要检查 $n$ 个元素。运行时间为 $\Theta (n)$。

2.2-4 我们应该如何修改算法，以使之具有较好的最佳运行时间？
解： 修改算法，测试输入是否满足某些特殊情况，如果满足，则输出预先计算的答案。 最佳情况下的运行时间通常不是衡量算法的好方法。

2.3 设计算法（Designing algorithms）

我们可从多种算法设计技术中进行选择。对于插入排序，我们使用了一种增量（incremental）方法：对子数组 $A[1..j]$ 进行了排序之后，将单个元素 $A[j]$ 插入其适当位置，生成排序后的子数组 $A[1..j]$。
在本节中，我们研究另一种设计方法，称为“分治”。我们使用分治来设计一种排序算法，该算法在最坏情况下的运行时间比插入排序的小很多。

2.3.1 分治法

许多算法在结构上都是递归的（recursive）：为了解决给定的问题，它们会递归地调用自身一次或多次，以处理相关的子问题。这些算法通常遵循分而治之（divide-and-conquer）的方法：将问题分解为几个与原问题相似但规模较小的子问题，递归求解子问题，然后组合这些解，得出原问题的解。

分治范式在递归的每次递归时都有三个步骤：
① 将问题分解（divide）为多个子问题，这些子问题是同一问题的较小实例。
② 通过递归解决（conquer）子问题。 如果子问题足够小，只需直接解决子问题即可。
③ 将子问题的解合并（combine）为原问题的解。

合并排序（merge sort）算法遵循上述分治法的范式。 操作如下。
分解： 将 $n$ 个元素的序列分为两个子序列，每个子序列有 $n/2$ 个元素。
解决： 使用合并排序对两个子序列进行递归排序。
合并： 合并两个已排序的子序列，得出排序的解。

假设子数组 $A[p..q]$ 和 $A[q+1..r]$ 是排序好的，将它们合并成一个排序好的数组代替当前的 $A[p..r]$。MERGE 过程的时间代价为 $\Theta (n)$，其中 $n=r-p+1$，为待合并的元素个数。伪代码如下。使用 $\infty$ 作为哨兵值（sentinel value）。

MERGE($A$, $p$, $q$, $r$)
 1 $n_1=q-p+1$
 2 $n_2=r-q$
 3 let $L[1..n_1+1]$ and $R[1..n_2+1]$ be new arrays
 4 for $i=1$ to $n_1$
 5   $L[i]=A[p+i-1]$
 6 for $j=1$ to $n_2$
 7   $R[j]=A[q+j]$
 8 $L[n_1+1]=\infty$
 9 $R[n_2+1]=\infty$
10 $i=1$
11 $j=1$
12 for $k=p$ to $r$
13   if $L[i]\le R[j]$
14     $A[k]=L[i]$
15     $i=i+1$
16   else
17     $A[k]=R[j]$
18     $j=j+1$

将 MERGE 过程作为合并排序算法中的子程序。过程 MERGE-SORT($A$, $p$, $r$) 对子数组 $A[p..r]$ 排序。

MERGE-SORT($A$, $p$, $r$)
1 if $p<r$
2   $q=\lfloor (p+r)/2\rfloor$
3   MERGE-SORT($A$, $p$, $q$)
4   MERDE-SORT($A$, $q+1$, $r$)
5   MERGE($A$, $p$, $q$, $r$)

C++代码如下：

// 条件：子序列 A[p..q] 是从小到大排序好的，子序列 A[q+1..r] 是从小到大排序好的void merge(vector<int>& A, int p, int q, int r){   	int n1 = q - p + 1;		// 子序列 A[p..q] 的个数	int n2 = r - q;			// 子序列 A[q+1..r] 的个数	vector<int> L(n1 + 1);	vector<int> R(n2 + 1);	for(int i=0; i<n1; ++i)	// 将 A[p..q] 的值赋值到 L[0..n1-1]		L[i] = A[p + i - 1];	for(int j=0; j<n2; ++j)	// 将 A[q+1..r] 的值赋值到 R[0..n2-1]		R[j] = A[q + j];	L[n1] = INT_MAX;	R[n2] = INT_MAX;	int i = 0;	int j = 0;	for(int k=p; k<=r; ++k)	{   		if(L[i] <= R[j])		{   			A[k] = L[i];			++i;		}		else		{   			A[k] = R[j];			++j;		}	}}void mergeSort(vector<int>& A, int p, int r){   	if(p < r)	// 当 p == r 时，A 中包含一个元素，是排序好的	{   		int q = (p + r) / 2;		mergeSort(A, p, q);		// 对子数组 A[p..q] 进行排序		mergeSort(A, q+1, r);	// 对子数组 A[q+1..r] 进行排序		merge(A, p, q, r);	}}

2.3.2 分析分治算法

当算法包含对自身的递归调用时，我们可以通过递归方程（recurrence equation）或递归式（recurrence）来描述其运行时间。使用数学工具来解递归方程式，给出算法性能的界限。
设问题规模为 $n$。如果规模足够小，如 $n\le c$，$c$ 为常数，则运行时间 $T(n)$ 为常量，可写为 $\Theta (1)$。假设将问题分解成 $a$ 个子问题，每个子问题的大小是原问题的 $1/b$。分解问题的时间记为 $D(n)$，合并问题的时间记为 $C(n)$。得到递归式如下：
$$T(n)=\{\begin{array}{rcl}\Theta (1)& & ifn\le c\\ aT(n/b)+D(n)+C(n)& & otherwise\end{array}$$

合并排序算法的分析

为了简化基于递归的分析，假定问题的规模为 2 的幂次。这样，每次分解后生成两个长度为 $n/2$ 的子序列。对一个元素进行合并排序需要常量时间。当元素个数 $n>1$ 时，运行时间分解如下。
分解： 计算子数组的中间位置，需要常量时间。$D(n)=\Theta (1)$。
解决： 递归解决两个子问题，每个子问题规模为 $n/2$，运行时间为 $2T(n/2)$。
合并： 在一个含有 $n$ 个元素的子数组中，MERGE 过程需要时间 $\Theta (n)$。$C(n)=\Theta (n)$。
函数 $\Theta (1)$ 与函数 $\Theta (n)$ 相加，得到一个线性函数，即 $\Theta (n)$。
令 $\Theta (1)=c$，则 $\Theta (n)=cn$。将上述递归式重写为：
$$T(n)=\{\begin{array}{rcl}c& & ifn=1\\ 2T(n/2)+cn& & ifn>1\end{array}$$

当 $n>1$ 时，构造递归树（recursion tree），计算整棵树的总代价为 $cn(\lg n+1)=cn\lg n+cn$。此处，$\lg n$ 为 ${\log }_{2}n$。忽略低阶项和常数，得出 $T(n)=\Theta (n\lg n)$。

练习

2.3-1 以图 2.4 为模型，说明数组 $A=⟨3,41,52,26,38,57,9,49⟩$ 合并排序的执行过程。
解：

2.3-2 重写 MERGE 过程，不使用哨兵，而改为：一旦数组 $L$ 或 $R$ 的所有元素都复制回数组 $A$ 中，立即停止，将另一个数组余下的元素复制回数组 $A$ 中。
解： MERGE($A$, $p$, $q$, $r$)
 1 $n_1=q-p+1$
 2 $n_2=r-q$
 3 let $L[1..n_1]$ and $R[1..n_2]$ be new arrays
 4 for $i=1$ to $n_1$
 5   $L[i]=A[p+i-1]$
 6 for $j=1$ to $n_2$
 7   $R[j]=A[q+j]$
 8 $i=1$
 9 $j=1$
10 $k=p$
11 while $i\le n_1$ and $j\le n_2$
12   if $L[i]\le R[j]$
13     $A[k]=L[i]$
14     $i=i+1$
15   else
16     $A[k]=R[j]$
17     $j=j+1$
18   $k=k+1$
19 if $i>n_1$
20   while $k\le r$
21     $A[k]=R[j]$
22     $k=k+1$
23     $j=j+1$
24 else
25   while $k\le r$
26     $A[k]=L[i]$
27     $k=k+1$
28     $i=i+1$

void merge(vector<int>& A, int p, int q, int r){   	int n1 = q - p + 1;		// 子序列 A[p..q] 的个数	int n2 = r - q;			// 子序列 A[q+1..r] 的个数	vector<int> L(n1);	vector<int> R(n2);	for(int i=0; i<n1; ++i)	// 将 A[p..q] 的值赋值到 L[0..n1-1]		L[i] = A[p + i - 1];	for(int j=0; j<n2; ++j)	// 将 A[q+1..r] 的值赋值到 R[0..n2-1]		R[j] = A[q + j];	int i = 0;	int j = 0;	int k = p;	while(i<n1 && j<n2)	{   		if(L[i] <= R[j])		{   			A[k] = L[i];			++i;		}		else		{   			A[k] = R[j];			++j;		}	}	if(i >= n1)	{   		for(; k <= r; ++k, ++j)			A[k] = R[j];	}	else	{   		for(; k <= r; ++k, ++i)			A[k] = L[i];	}}

2.3-3 利用数学归纳法证明：当 $n$ 是 2 的整数次幂，递归式
$$T(n)=\{\begin{array}{rcl}2& & ifn=2\\ 2T(n/2)+n& & ifn=2^k,fork>1\end{array}$$ 的解是 $T(n)=n\lg n$。
证： ① 验证 $k=1,2$，即 $n=2,4$ 时，等式 $T(n)=n\lg n$ 成立。当 $k=1$ 时，左边 $=2$，右边 $=2\lg 2=2$，所以这个等式在 $k=1$ 时成立。当 $k=2$ 时，左边 $=2T(2)+4=8$，右边 $=4\lg 4=8$，所以这个等式在 $k=2$ 时成立。第一步完成。
② 我们需要证明，如果假设 $k=m$ 时公式成立（$m>1$），那么可以推导出 $k=m+1$ 时公式也成立，即，从 $T(2^m)=2^m\lg 2^m$ 推导出 $T(2^{m+1})=(m+1)\lg 2^{m+1}$ 可证明等式 $T(n)=n\lg n$ 成立。证明步骤如下。
我们先假设 $k=m$ 时公式成立。此时，$n=2^m$。则有：
左边 $=T(n)=T(2^m)=2T(2^m/2)+2^m=2T(2^{m-1})+2^m$。
右边 $=n\lg n=2^m\lg 2^m=m\times 2^m$。
由 左边 = 右边，得到，$2T(2^{m-1})+2^m=m\times 2^m$。
将两边同时乘以 2，得到 $4T(2^{m-1})+2^{m+1}=m\times 2^{m+1}$。
将两边同时加上 $2^{m+1}$，得到 $4T(2^{m-1})+2\times 2^{m+1}=(m+1)\times 2^{m+1}$   (1)
$4T(2^{m-1})+2\times 2^{m+1}=2(2T(2^m/2)+2^m)+2^{m+1}=2T(2^m)+2^{m+1}=T(2^{m+1})$   (2)
$(m+1)\times 2^{m+1}=(m+1)\lg 2^{m+1}$   (3)
由 (1)、(2)、(3)，得出 $T(2^{m+1})=(m+1)\lg 2^{m+1}$。
综上所述，等式 $T(n)=n\lg n$ 成立，即递归式的解时 $T(n)=n\lg n$ 。

2.3-4 我们可以将插入排序表示为递归过程。为了排序 $A[1..n]$ ，我们递归地排序 $A[1..n-1]$，接着将 $A[n]$ 插入到已排序的 $A[1..n-1]$ 中。对于这个递归版本的插入排序，写出其运行时间的递归式。
解： C++ 代码如下：

void insertionSort(vector<int>& A, int n){   	if(n == 1)  // A中包含一个元素是排序好的		return;	int elem = A[n-1];	insertionSort(A, n-1);	int i = n-1;	for(; i>0; --i)	{   		if(A[i-1] > elem)			A[i] = A[i-1];		else			break;	}	A[i] = elem;}

最坏情况下，运行时间的递归式如下：
$T(n)=\{\begin{array}{rcl}\Theta (1)& & ifn=1\\ T(n-1)+\Theta (n)& & ifn>1\end{array}$

2.3-5 回顾一下查找问题（见练习 2.1-3），观察到，如果序列 $A$ 已经排序，我们可以将序列的中点与 $v$ 进行比较，再进一步考虑时，可以剔除原序列的一半。二分查找（binary search）算法重复此过程，每次序列余下的部分大小减半。 写出二分查找的伪代码，可以使用迭代或递归。 说明二分查找的最坏情况运行时间为 $\Theta (\lg n)$。
解： 迭代法如下：
BINARY-SEARCH($A$, $v$)
 1 $low=1$
 2 $high=A.length$
 3 while $low\le high$
 4  $mid=low+\lfloor (high-low)/2\rfloor$
 5  if $v==A[mid]$
 6   return $mid$
 7  else if $v<A[mid]$
 8   $high=mid-1$
 9  else
10   $low=mid+1$
11 return NIL

递归法如下：
BINARY-SEARCH($A$, $v$, $low$, $high$)
1 if $low>high$
2 return NIL
3 $mid=low+\lfloor (high-low)/2\rfloor$
4 if $v==A[mid]$
5  return $mid$
6 else if $v<A[mid]$
7  BINARY-SEARCH($A$, $v$, $low$, $mid-1$)
8 else
9  BINARY-SEARCH($A$, $v$, $mid+1$, $high$)

每次查找范围减半，所以最坏情况下，运行时间的递归式如下：
$T(n)=\{\begin{array}{rcl}\Theta (1)& & 当范围为空，即low>high\\ T(n/2)+\Theta (1)& & 其他，即low\le high\end{array}$
由递归树可推导出 $T(n)=\Theta (\lg n)$。

2.3-6 观察章节 2.1 中 INSERTION-SORT 过程，在 5 - 7 行的 while 循环中，使用线性查找方式，在已排序的 $A[1..j]$ 中（反向）扫描。我们可以使用二分查找（见练习 2.3-5），将插入排序的最坏情况运行时间改善至 $\Theta (n\lg n)$。
解： 不能。找到一个元素的插入位置所需时间可以改善至 $\Theta (\lg n)$，但将一个元素插入到适当位置则依旧需要时间 $\Theta (n)$。

2.3-7 写出一个运行时间为 $\Theta (n\lg n)$ 的算法：给出一个包含 $n$ 个整数的集合 $S$，一个整数 $x$，找出集合 $S$ 中是否存在两个元素，这两个元素之和等于 $x$。
解： CHECK($S$, $x$)
 1 MERGE-SORT($S$, $1$, $n$)
 2 $low=1$
 3 $high=n$
 4 while $low<high$
 5  if $S[low]+S[high]==x$
 6   return $S[low]$, $S[high]$
 7  else if $S[low]+S[high]>x$
 8   $high=high-1$
 9  else
10   $low=low+1$
11 return NIL
先使用归并排序算法对集合 $S$ 进行排序，需要时间为 $\Theta (n\lg n)$。接着使用双指针法找出集合 $S$ 中和为 $x$ 的两个元素，需要时间为 $\Theta (n)$。所以，总运行时间为 $T(n)=\Theta (n\lg n)+\Theta (n)+\Theta (1)$，去掉低阶项和常量，得到 $T(n)=\Theta (n\lg n)$。

问题

2-1 在合并排序中对小数组进行插入排序
尽管合并排序的最坏情况运行时间为 $\Theta (n\lg n)$，插入排序的最坏情况运行时间为 $\Theta (n^2)$，但是在许多机器上，问题规模较小时，插入排序的常数因子使得它实际运行得更快。因此，在合并排序中，当子问题的规模足够小时，使用插入排序可行。考虑对合并排序的作出修改：使用插入排序对 $n/k$ 个长度为 $k$ 子列表进行排序，然后使用标准合并机制进行合并，其中 $k$ 是一个待定的值。
a. 证明：在最坏情况下，使用插入排序对 $n/k$ 个长度为 $k$ 子列表进行排序，运行时间为 $\Theta (nk)$。
b. 在最坏情况下，如何在时间 $\Theta (n\lg (n/k))$ 内，完成子列表的合并。
c. 假定修改后的算法在最坏情况下运行时间为 $\Theta (nk+n\lg (n/k))$，要使修改后的算法运行时间与标准合并排序一样，$k$ 的最大值是多少？以 $\Theta$ 形式表示为关于 $n$ 的函数。
d. 在实际中，应该如何选择 $k$ 值？
解： a. 证：在最坏情况下，对一个长度为 $k$ 子列表进行插入排序，其运行时间可表示为 $\Theta (k^2)$。因为要排序 $n/k$ 个子列表，所以总运行时间为 $(n/k)\cdot \Theta (k^2)=\Theta (nk)$。
b. 子列表的合并使用合并排序算法。构造递归树，在该树中，总共有 $\lg (n/k)+1$ 层，每层的代价都是 $\Theta (n)$，所以，整棵树的总代价是 $\Theta (n\lg (n/k)+n)$，忽略低阶项，运行时间为 $\Theta (n\lg (n/k))$。
c. 根据题意，$\Theta (nk+n\lg (n/k))$ 的最高阶项的幂次不能超过 $\Theta (n\lg n)$。$k$ 的最大值是 $\Theta (\lg n)$。
d. 选择的 $k$ 值应该使得插入排序的运行时间比合并排序的运行时间要快。

2-2 冒泡排序算法的正确性
冒泡排序法是一种流行的但效率不高的算法，其工作机制是通过重复交换两个相邻的无序的元素来排序。
BUBBLESORT($A$)
1 for $i=1$ to $A.length-1$
2  for $j=A.length$ downto $i+1$
3   if $A[j]<A[j-1]$
4    exchange $A[j]$ with $A[j-1]$
a. 设 $A^{\prime }$ 表示 BUBBLESORT($A$) 的输出。为了证明 BUBBLESORT 是正确的，我们需要证明它可以终止，并且：
$A^{\prime }[1]\le A^{\prime }[2]\le \cdots \le A^{\prime }[n](2.3)$
其中 $n=A.length$。为了证明 BUBBLESORT 确实可以实现排序，还需要证明什么？
下面两个部分证明不等式（2.3）。
b. 对于第 2-4 行中的 for 循环，准确指出其循环不变式，并证明该循环不变式成立。 证明应使用本章介绍的循环不变式证明的结构。
c. 使用在（b）部分中证明的循环不变式的终止条件，为第1–4行中的 for 循环给出一个循环不变式，这可以用来证明不等式（2.3）。 证明应使用本章介绍的循环不变式证明的结构。
d. 冒泡排序的最坏情况运行时间是多少？比较它与插入排序的运行时间。
解： a. 还需要证明序列 $A^{\prime }$ 是序列 $A$ 的重新排序。
b. 证：循环不变式：$A[j]$ 是 $A[j..n]$ 中最小的元素。
初始： 在循环第一次迭代之前，$j=n$，此时 $A[j..n]$ 中只有一个元素 $A[n]$，循环不变式为真。
保持： 若 $A[j-1]>A[j]$，则 $A[j]$ 和 $A[j-1]$ 的值会交换，此时 $A[j-1]<A[i]$；否则 $A[j]$ 和 $A[j-1]$ 保持不变，此时有 $A[j-1]\le A[j]$。$A[j-1]\le A[j]$ 恒成立，而 $A[j]$ 是 $A[j..n]$ 中最小的元素，所以，$A[j-1]$ 是 $A[j-1..n]$ 中最小的元素。在下一次迭代前，循环不变式为真。
终止： 当 $j=i+1$ 时，循环终止。$A[i]$ 是序列$A[i..n]$ 中最小的元素。
综上，循环不变式成立。
c. 证：循环不变式：$A[1..i]$ 是排序好的。
初始： 在循环第一次迭代之前，序列 $A[1..i]$ 只有一个元素 $A[1]$，循环不变式成立。
保持： 由（b）部分，知 $A[i]$ 是$A[i..n]$ 中最小的元素，所以 $A[i+1..n]$ 内的值均大于 $A[i]$，且 $A[1..i]$ 是排序好的。因此，$A[1..i+1]$ 是排序好的。在下一次迭代前，循环不变式为真。
终止： 当 $i=n-1$ 时，循环终止。$A[1..n]$ 是排序好的。
综上，循环不变式成立。不等式（2.3）成立。
d. 冒泡排序的最坏运行时间是 $\Theta (n^2)$。考虑常数因子，冒泡排序比插入排序运行得慢。

2-3 霍纳规则的正确性
下面的代码片段实现了用于计算多项式的霍纳规则（Horner’s rule）
$P(x)={\sum }_{k=0}^n{a}_k{x}^k=a_0+x(a_1+x(a_2+\cdots +x(a_{n-1}+x{a}_n)\cdots ))$，
给定系数 $a_0,a_1,\dots ,a_n$ 和 $x$ 的值：
1 $y=0$
2 for $i=n$ downto 0
3  $y=a_i+x\cdot y$
a. 这段实现霍纳规则的代码运行时间是多少？以 $\Theta$ 形式表示。
b. 写出伪代码以实现朴素多项式求值算法（naive polynomial-evaluation algorithm），该算法从头开始计算多项式的每个项。该算法的运行时间是多少？与霍纳规则相比如何？
c. 考虑下面的循环不变式：
在第 2–3 行的 for 循环的每次迭代开始时，$y={\sum }_{k=0}^{n-(i+1)}{a}_{k+i+1}{x}^k$。
不包含任何项的和等于 0。按照本章介绍的循环不变式证明的结构，使用该循环不变式证明，在终止时，有 $y={\sum }_{k=0}^n{a}_k{x}^k$。
d. 推断：给出的代码片段能够正确地计算以系数 $a_0,a_1,\dots ,a_n$ 为特征的多项式。
解： a. 这段代码运行时间是 $\Theta (n)$。
b. 朴素多项式求值算法伪代码如下：
1 $y=0$
2 $s=1$
3 for $i=0$ to $n$
4  $y=y+a_i\cdot s$
5  $s=x\cdot s$
该算法的运行时间为 $\Theta (n)$。考虑常数因子，该算法比霍纳规则的实现代码慢。
c. $y={\sum }_{k=0}^{n-(i+1)}{a}_{k+i+1}{x}^k=a_{i+1}+a_{i+2}\cdot x+\cdots +a_n\cdot x^{n-(i+1)}$。
初始： 在循环第一次迭代前，$y=0$，$i=n$，此时多项式不包含任何项，${\sum }_{k=0}^{n-(i+1)}{a}_{k+i+1}{x}^k$ 等于 0。循环不变式为真。
保持： 由第 3 行代码得，在进行当前迭代时，$y_{i-1}=a_i+x\cdot y_i$。
假设上一次迭代时循环不变式为真，将 $y_i={\sum }_{k=0}^{n-(i+1)}{a}_{k+i+1}{x}^k$ 代入上式得，
$$\begin{gathered} y_{i-1}=a_i+x\cdot {\sum }_{k=0}^{n-(i+1)}{a}_{k+i+1}{x}^k \\ =a_i+a_{i+1}\cdot x+a_{i+2}\cdot x^2+\cdots +a_n\cdot x^{n-i} \\ ={\sum }_{k=0}^{n-i}{a}_{k+i}{x}^k \\ ={\sum }_{k=0}^{n-((i-1)+1)}{a}_{k+(i-1)+1}{x}^k \end{gathered}$$。
所以，在下一次迭代之前，循环不变式为真。
终止： 当 $i=0$ 时，循环终止。此时，有 $y={\sum }_{k=0}^n{a}_k{x}^k$。
d. 由部分（c）可以推断出此结论。

2-4 逆序对（Inversions）
设 $A[1..n]$ 是一个包含 $n$ 个不同数字的数组。如果 $i<j$ 且 $A[i]>A[j]$，那么 $(i,j)$ 被称为 $A$ 中的一个逆序对。
a. 列出数组 $⟨2,3,8,6,1⟩$ 中的 5 个逆序对。
b. 如果数组的元素取自集合 { 1 , 2 , … , n } \{1,2,\dots,n\} { 1,2,…,n}，那么怎样的数组中逆序对最多？包含的逆序对是多少？
c. 插入排序的运行时间与输入数组中的逆序对的数目之间有什么关系？说明你的理由。
d. 给出一个算法，确定 $n$ 个元素的任何排列中的逆序对的数目，其最坏情况运行时间为 $\Theta (n\lg n)$。（提示：修改合并排序。）
解： a. 逆序对：$(1,5)$，$(2,5)$，$(3,4)$，$(3,5)$，$(4,5)$。
b. 数组 $⟨n,n-1,n-2,\dots ,2,1⟩$ 中逆序对的数目最多。逆序对数目有 $n(n-1)/2$ 个。
c. 输入数组中的逆序对的数目越多，插入排序的运行时间越长。
过程 INSERTION-SORT 的外部 for 循环中，$i<j$ 总是成立，$key=A[j]$。如果 $A[i]>key$，那么 $(i,j)$ 就是一个逆序对，在内部 while 循环（代码第 5-7 行）中可以看出，此时每次迭代需要移动元素一次，消除一个逆序对。所以，输入数组中的逆序对的数目越多，插入排序需要消除的逆序对越多，其内循环移动元素的次数就越多，插入排序的运行时间就越长。
d. 题目要求的算法如过程 INVERSIONS-NUM 所示。

INVERSIONS-MERGE($A$, $p$, $q$, $r$)
 1 $n_1=q-p+1$
 2 $n_2=r-q$
 3 let $L[1..n_1+1]$ and $R[1..n_2+1]$ be new arrays
 4 for $i=1$ to $n_1$
 5   $L[i]=A[p+i-1]$
 6 for $j=1$ to $n_2$
 7   $R[j]=A[q+j]$
 8 $L[n_1+1]=\infty$
 9 $R[n_2+1]=\infty$
10 $i=1$
11 $j=1$
12 $num=0$
13 for $k=p$ to $r$
14  if $L[i]\le R[j]$
15   $A[k]=L[i]$
16   $i=i+1$
17  else
18   $num=num+n_1-i+1$  // 因为 $L[1..n_1]$ 有序，所以$L[i..n_1]$ 中的值均大于 $R[j]$
19   $A[k]=R[j]$
20   $j=j+1$
21 return $num$

INVERSIONS-NUM($A$, $p$, $r$)
1 $num=0$
2 if $p<r$
3   $q=\lfloor (p+r)/2\rfloor$
4   $num=num+$ INVERSIONS-NUM($A$, $p$, $q$)
5   $num=num+$ INVERSIONS-NUM($A$, $q+1$, $r$)
6   $num=num+$ INVERSIONS-MERGE($A$, $p$, $q$, $r$)
7 return $num$

学习笔记目录：