练习
2.1-1 以图2-2为模型，说明INSERTION-SORT在数组A=[31,41,59,26,41,58]上的执行过程。
[31,41,59,26,41,58] key = 41
[31,41,59,26,41,58] key = 59
[31,41,59,26,41,58] key = 26
[31,41,59,59,41,58] key = 26
[31,41,41,59,41,58] key = 26
[31,31,41,59,41,58] key = 26
[26,31,41,59,41,58] key = 26
[26,31,41,59,41,58] key = 41
[26,31,41,59,59,58] key = 41
[26,31,41,41,59,58] key = 41
[26,31,41,41,59,58] key = 58
[26,31,41,41,59,59] key = 58
[26,31,41,41,58,59] key = NIL
2.1-2 重写过程INSERTION-SORT，使之按照非升序排序。
void INSERTION_SORT(int A[], int len)
{
for (int i = 1; i < len; ++i) {
int j = i;
int val = A[j];
while (j > 0 && val > A[j - 1]) {
A[j] = A[j - 1];
j = j - 1;
}
A[j] = val;
}
}
2.1-3 考虑以下查找问题：
输入：n个数的一个序列A={a[i]}和一个值v。
输出：下标i使得v=A[i]或者当v不在A中出现时，v为特殊值NIL。
写出线性查找的伪代码，它扫描整个序列来查找v。使用一个循环不变式来证明你的算法是正确的。确保你的循环不变式满足三条必要的性质。
int search(int A[], int len, int v)
{
for (int i = 0; i < len; ++i) {
if (v = A[i]) return i;
}
return -1;
}
初始化：i的值为0，且i < len成立。
保持：每次迭代之后i自增1，当i < len时总是满足条件，且0~i-1之间的元素是被检查过的。
终止：要么在每次循环中满足条件v = A[i]后终止；要么当i不小于len后终止，这时0~n - 1的元素是被检查过的，故算法正确。
2.1-4 考虑把两个n位二进制整数加起来的问题，这两个整数分别存储在两个n元数组A和B中。这两个整数的和应该按照二进制形式存储在一个(n + 1)元数组C中。请给出该问题的形式化描述，并写出伪代码。
int* binary_sum(int A[], int B[], int n)
{
int* C = new int[n + 1];
int is_overflow = 0;
for (int i = n - 1, k = n; i >= 0; --i, --k) {
C[k] = A[i] + B[i] + is_overflow;
if (C[k] > 1) is_overflow = 1;
else is_overflow = 0;
C[k] %= 2;
}
C[k] = is_overflow;
return C;
}
练习
2.2-1 用Θ记号表示函数n^3 / 1000 - 100n^2 - 100n + 3。
取最大项并且舍去常数系数得到：Θ(n^3)
2.2-2 考虑排序存储在A数组A中的n个数：首先找出A中的最小元素并将其与A[1]中的元素进行交换。接着，找出A中次小的元素并将其与A[2]中的元素进行交换。对A中前n - 1个元素按该方式继续。该算法称为选择算法，写出伪代码。该算法维持的循环不变式是什么？为什么它只需要对前n-1个元素，而不是对所有n个元素运行？用Θ记号给出选择排序的最好情况和最快情况运行时间。
void selection_sort(int A[], int len)
{
for (int i = 0; i < len - 1; ++i) {
int min_index = i;
for (int j = i; j < len; ++j) {
if (A[j] < A[min_index]) min_index = j;
}
std::swap(A[i], A[min_index]);
}
}
因为前n-1个元素就位的时候，第n个元素也一定会就位，所以只用处理n-1个元素。
最好情况：Θ(n^2)。因为不管怎样，都要进行元素检查，即使数组是有序的。
最坏情况：Θ(n^2)。
2.2-3 再次考虑线性查找问题，假定要查找的元素等可能的为数组中的任意元素，平均需要检查输入序列的多少元素？最坏情况又如何呢？用Θ记号给出线性查找的平均情况和最坏运行情况。证明你的答案。
最好的情况是第一个元素就找到，只需要常数的时间，而最坏的情况则需要遍历整个数组才能找到，需要n的时间。于是平均需要检查(n + 1) / 2个元素。
平均情况：Θ(n)。这里舍去了常数系数。
最坏情况：Θ(n)。
2.2-4 我们可以如何修改几乎任意算法来使之具有良好的运行情况运行时间？
根据输入数据的情况去专门设计算法，也就是倒推。
练习
2.3-1 使用图2-4作为模型，说明归并排序在数组A = [3,41,52,26,38,57,9,49]上的操作。
[3,41,52,26,38,57,9,49]
[3,41,52,26] [38,57,9,49]
[3,41] [52,26] [38,57] [9,49]
[3] [41] [52] [26] [38] [57] [9] [49] 这里是极限状态，接下来就是merge的环节
[3,41] [26,52] [38,57] [9,49]
[3,26,41,52] [9,38,49,57]
[3,9,26,38,41,49,52,57]
2.3-2 重写MERGE，使之不用哨兵，而是一旦数组L或者R的所有元素均被复制回A就立刻停止，然后把另一个数组的剩余部分复制回A。
void merge(std::vector<int>& A, int begin, int middle, int end)
{
std::vector<int> temp = A;
int i = begin;
int j = middle + 1;
for (int k = begin; k <= end; ++k) {
if (i > middle) A[k] = temp[j++];
else if (j > end) A[k] = temp[i++];
else if (temp[i] < temp[j]) A[k] = temp[i++];
else A[k] = temp[j++];
}
}
2.3-3 2.3-4 TODO
2.3-5 回顾查找问题，注意到，如果序列A已经排好序，就可以将该序列的中点与v进行比较。根据比较的结果，原序列中有一半就可以不用再做进一步考虑了。二分查找算法重复这个过程，每次都将序列剩余部分的规模减半。为二分查找写出迭代或者递归的伪代码。证明：二分查找的最坏情况运行时间为Θ(nlgn)。
int binary_search(std::vector<int>& A, int val)
{
int begin = 0;
int end = A.size() - 1;
while (begin < end) {
int mid = begin + (end - begin) / 2;
if (val < A[mid]) end = mid - 1;
else if (val > A[mid]) begin = mid + 1;
else return mid;
}
return -1;
}
2.3-6 我们可以使用二分查找来把插入排序的最坏情况总运行时间改进到Θ(nlgn)吗？
在链表上可以做到，但是在线性表上是不行的，因为线性表的插入总是需要和数组长度为线性关系的时间。
2.3-7 TODO
