MIT-算法导论读书笔记-第二章-part1

MIT-算法导论读书笔记-第二章-part1

给出的代码目前也仅仅为解决问题，没有做优化，请见谅，等有时间了我再好好修改。

插入排序算法伪代码

INSERTION-SORT(A)

1 for j←2 to length[A]

2 do 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 do A[i+1] ← A[i]

7 i←i-1

8 A[i+1] ← key

C#对插入排序算法的实现:

public static void InsertionSort<T>(T[] Input) where T:IComparable<T>

{

T key;

int i;

for (int j = 1; j < Input.Length; j++)

{

key = Input[j];

i = j - 1;

for (; i >= 0 && Input[i].CompareTo(key)>0;i-- )

Input[i + 1] = Input[i];

Input[i+1]=key;

}

}

Insertion-sort的C语言实现：

/* insertion-sort(A) 插入排序算法 */

#include "stdio.h"

void main()

{

int A[10],i,j,key;

printf("pls input 10 numbers!\n>>");

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

scanf("%d",&A[i]);

for(j=1;j<=9;++j)

{

key=A[j];

i=j-1;

while(i>0 && A[i]>key)

{

A[i+1]=A[i];

i=i-1;

}

A[i+1]=key;

}

printf("the sort is:\n");

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

printf("%d\n",A[i]);

}

插入算法的设计使用的是增量（incremental）方法：在排好子数组A[1..j-1]后，将元素A[j]插入，形成排好序的子数组A[1..j]

这里需要注意的是由于大部分编程语言的数组都是从0开始算起，这个与伪代码认为的数组的数是第1个有所不同，一般要注意有几个关键值要比伪代码的小1.

如果按照大部分计算机编程语言的思路，修改为：

INSERTION-SORT(A)

1 for j←1 to length[A]

2 do key←A[j]

3 i←j-1

4 while i>=0 and A[i]>key

5 do A[i+1] ← A[i]

6 i←i-1

7 A[i+1] ← key

循环不变式(Loop Invariant)是证明算法正确性的一个重要工具。对于循环不变式，必须证明它的三个性质：

初始化(Initialization)：它在循环的第一轮迭代开始之前，应该是正确的。

保持(Maintenance)：如果在循环的某一次迭代开始之前它是正确的，那么，在下一次迭代开始之前，它也是正确的。

终止(Termination)：当循环结束时，不变式给了我们一个有用的性质，它有助于表明算法是正确的。

运用循环不变式对插入排序算法的正确性进行证明：

初始化：j=2，子数组A[1..j-1]只包含一个元素A[1],显然它是已排序的。

保持：若A[1..j-1]是已排序的，则按照大小确定了插入元素A[j]位置之后的数组A[1..j]显然也是已排序的。

终止：当j=n+1时，退出循环，此时已排序的数组是由A[1],A[2],A[3]…A[n]组成的A[1..n]，此即原始数组A。

练习

2.1-1：以图2-2为模型，说明INSERTION-SORT在数组A=<31,41,59,26,41,58>上的执行过程。

（2.1-1

Using Figure 2.2 as a model, illustrate the operation of INSERTION-SORT on the array A D h31; 41; 59; 26; 41; 58i.）

31

41

59

26

41

58

31

41

59

26

41

58

31

41

59

26

41

58

26

31

41

59

41

58

26

31

41

41

59

58

26

31

41

41

58

59

2.1-2：重写过程INSERTION-SORT，使之按非升序（而不是按非降序）排序。

（2.1-2

Rewrite the INSERTION-SORT procedure to sort into nonincreasing instead of nondecreasing

order.）

INSERTION-SORT(A)

1 for j←2 to length[A]

2 do key←A[j]

3 //Insert A[j] into the sorted sequence A[1..j-1]

4 i←j-1

5 while and A[i]<key

6 do A[i+1] ← A[i]

7 i←i-1

7 A[i+1] ← key

2.1-3：考虑下面的查找问题：

输入：一列数A=<a1,a2,…,an >和一个值v

输出：下标i，使得v=A[i]，或者当v不在A中出现时为NIL。

写出针对这个问题的现行查找的伪代码，它顺序地扫描整个序列以查找v。利用循环不变式证明算法的正确性。确保所给出的循环不变式满足三个必要的性质。

（2.1-3

Consider the searching problem:

Input: A sequence of n numbers A D ha1; a2; : : : ;ani and a value _.

Output: An index i such that _ D AOEi_ or the special value NIL if _ does not

appear in A.

Write pseudocode for linear search, which scans through the sequence, looking

for _. Using a loop invariant, prove that your algorithm is correct. Make sure that

your loop invariant fulfills the three necessary properties.）

LINEAR-SEARCH(A,v)

1 for i←1 to length[A]

2 if v=A[i]

3 return i

4 return NIL

现行查找算法正确性的证明。

初始化： i=1，子数组为A[1..i]，只有一个元素A[1],如果v=A[1]就返回1,否则返回NIL，算法显然是正确的。

保持：若算法对数组A[1..i]正确，则在数组增加一个元素A[i+1]时，只需要多作一次比较，因此显然对A[1..i+1]也正确。

终止：算法如果在非最坏情况下定能返回一个值此时查找成功，如果n次查找（遍历了所有的数）都没有成功，则返回NIL。算法在有限次查找后肯定能够给出一个返回值，要么说明查找成功并给出下标，要么说明无此值。因此算法正确。

该算法用C#实现的代码：

public static int LinearSearch<T>(T[] Input, T v) where T:IComparable<T>

{

for (int i = 0; i < Input.Length;i++ )

if (Input[i].Equals(v))

return i;

return -1;

}

2.1-4：有两个各存放在数组A和B中的n位二进制整数，考虑它们的相加问题。两个整数的和以二进制形式存放在具有(n+1)个元素的数组C中。请给出这个问题的形式化描述，并写出伪代码。

（Consider the problem of adding two n-bit binary integers, stored in two n-element arrays A and B. The sum of the two integers should be stored in binary form in an (n+1)-element array C. State the problem formally and write pseudocode for adding the two integers.）

A存放了一个二进制n位整数的各位数值，B存放了另一个同样是二进制n位整数的各位上的数值，现在通过二进制的加法对这两个数进行计算，结果以二进制形式把各位上的数值存放在数组C（n+1位）中。

BINARY-ADD(A,B,C)

1 flag← 0

2 for j←1 to n

3 do key←A[j]+B[j]+flag

4 C[j] ← key mod 2

5 if key←1

6 flag←1

7 if flag=1

8 C[n+1] ← 1

1.RAM(Random-Access Machine)模型分析通常能够很好地预测实际计算机上的性能，RAM计算模型中，指令一条接一条地执行，没有并发操作。RAM模型中包含了真实计算机中常见的指令：算术指令（加法、剑法、乘法、出发、取余、向下取整、向上取整指令）、数据移动指令（装入、存储、复制指令）和控制指令（条件和非条件转移、子程序调用和返回指令）。其中每天指令所需时间都为常量。

RAM模型中的数据类型有整数类型和浮点实数类型。

2.算法的运行时间是指在特定输入时，所执行的基本操作数（或步数）。

插入算法的分析比较简单，但是不是很有用，所以略过。（在解思考题2-1时有具体的实例分析，请参看）

3.一般考察算法的最坏情况运行时间。这样做的理由有三点：

A．一个算法的最坏情况运行时间是在任何输入下运行时间的一个上界。

B．对于某些算法，最坏情况出现的是相当频繁的。

C．大致上来看，“平均情况“通常与最坏情况一样差。

4.如果一个算法的最坏情况运行时间要比另一个算法的低，我们常常就认为它的效率更高。

练习

2.2-1：用Θ形式表示表示函数 /1000- -100n+3

(2.2-1

Express the function n3=1000 _ 100n2 _ 100n C 3 in terms of ‚Θ-notation.)

Θ(n^3)

2.2-2:考虑对数组A中的n个数进行排序的问题：首先找出A中的最小元素，并将其与A[1]中的元素进行交换。接着，找出A中的次最小元素，并将其与A[2]中的元素进行交换。对A中头n-1个元素继续这一过程。写出这个算法的伪代码，该算法称为选择排序（selection sort）。对这个算法来说，循环不变式是什么?为什么它仅需要在头n-1个元素上运行，而不是在所有n个元素上运行？以 形式写出选择排序的最佳和最坏情况下的运行时间。

(2.2-2

Consider sorting n numbers stored in array A by first finding the smallest element

of A and exchanging it with the element in A[1]. Then find the second smallest

element of A, and exchange it with A[2]. Continue in this manner for the first n-1

elements of A. Write pseudocode for this algorithm, which is known as selection

sort. What loop invariant does this algorithm maintain? Why does it need to run

for only the first n -1 elements, rather than for all n elements? Give the best-case

and worst-case running times of selection sort in Θ-notation.)

假设函数MIN(A,i,n)从子数组A[i..n]中找出最小值并返回最小值的下标。

SELECTION-SORT(A)

1 for i←1 to n-1

2 j←MIN(A,i,n)

3 exchange A[i]←→ A[j]

选择排序算法正确性的证明

初始化：i=1，从子数组A[1..n]里找到最小值A[j]，并与A[i]互换，此时子数组A[1..i]只有一个元素A[1]，显然是已排序的。

保持：若A[1..i]是已排序子数组。这里显然A[1] A[2] A[3] … A[i]，而A[i+1..n]里最小值也必大于A[i]，找出此最小值与A[i+1]互换并将A[i+1]插入A[1..i]得到子数组A[1..i+1]。A[1..i+1]显然也是已排序的。

终止：当i=n时终止，此时已得到已排序数组A[1..n-1]，而A[n]是经过n-1次比较后剩下的元素，因此A[n]大于A[1..n-1]中任意元素，故数组A[1..n]也即是原数组此时已是已排序的。所以，算法正确。

仅需要在头n-1个元素上运行是因为经过n-1次比较后剩下的是最大元素，其理应排在最后一个位置上，因此可以不必对此元素进行交换位置操作。

由于MIN()函数和SWAP()函数对于任意情况运行时间都相等，故这里最佳和最坏情况下运行时间是一样的。 Θ(n^2)

选择算法的的C#实现：

private static int Min<T>(T[] Input,int start,int end) where T:IComparable<T>

{

int flag=start;

for (int i = start; i < end; i++)

if (Input[flag].CompareTo(Input[i]) > 0)

flag = i;

return flag;

}

private static void Swap<T>(ref T a,ref T b) where T : IComparable<T>

{

T temp;

temp = a;

a = b;

b = temp;

}

public static T[] SelectionSort<T>(T[] Input) where T:IComparable<T>

{

for (int i = 0; i < Input.Length - 1; i++)

Swap(ref Input[Min(Input, i, Input.Length)],ref Input[i]);

return Input;

}

2.2-3：再次考虑线性查找问题（见练习2.1-3）。在平均情况下，需要检查输入序列中的多少个元素？假定查找的元素是数组中任何一个元素的可能性都是相等的。在最坏情况下又怎么样呢？用Θ相似表示的话，线性查找的平均情况和最坏情况运行时间怎么样？对你的答案加以说明。

(2.2-3

Consider linear search again (see Exercise 2.1-3). How many elements of the input

sequence need to be checked on the average, assuming that the element being

searched for is equally likely to be any element in the array? How about in the

worst case? What are the average-case and worst-case running times of linear

search in Θ-notation? Justify your answers.)

平均：n/2次。因为任意一个元素大于、小于查找数的概率一样。

最坏：n次。最后一个元素才是要查找的元素。

用Θ表示都是：Θ(n)

2.2-4：应如何修改一个算法，才能使之具有较好的最佳情况运行时间？

(How can we modify almost any algorithm to have a good best-case running time?)

要使算法具有较好的最佳情况运行时间就一定要对输入进行控制，使之偏向能够使得算法具有最佳运行情况的排列。

5.分治法（divide-and-conquer）:有很多算法在结构上是递归的：为了解决一个给定的问题，算法要一次或多次地递归调用其自身来解决相关的问题。这些算法通常采用分治策略：将原问题划分成n个规模较小而结构与原问题相似的子问题；递归地解决这些子问题，然后再合并其结果，就得到原问题的解。

容易确定运行时间，是分治算法的有点之一。

6.分治模式在每一层递归上都有三个步骤：

分解（Divide）：将原问题分解成一系列子问题；

解决（Conquer）：递归地解各子问题。若子问题足够小，则直接求解；

合并（Combine）：将子问题的结果合并成原问题的解。

7.合并排序（Merge Sort）算法完全依照了分治模式。

分解：将n个元素分成各含n/2个元素的子序列；

解决：用合并排序法对两个子序列递归地排序；

合并：合并两个已排序的子序列以得到排序结果。

在对子序列排序时，其长度为1时递归结束。单个元素被视为是已排好序的。

合并排序的关键步骤在于合并步骤中的合并两个已排序子序列。为做合并，引入一个辅助过程MERGE(A,p,q,r)，其中A是个数组，p、q和r是下标，满足 。该过程假设子数组A[p..q]和A[q+1..r]都已排好序，并将他们合并成一个已排好序的子数组代替当前子数组A[p..r]。

MERGE过程的时间代价为Θ(n)，其中n=r-p+1是待合并的元素个数。

MERGE过程:

MERGE(A,p,q,r)

1 n1←q-p+n

2 n2←r-p

3 //create arrays L[1..n1+1] and R[1..n2+1]

4 for i←1 to n1

5 do L[i] ← A[p+i-1]

6 for j←1 to n2

7 do R[j] ← A[q+j]

8 L[ ] ←无穷

9 R[ ] ←无穷

10 i←1

11 j←1

12 for k←p to r

13 do if L[i]<= R[j]

14 then A[k] ← L[i]

15 i←i+1

16 else A[k] ← R[j]

17 j←j+1

MERGE过程正确性的证明

初始化：第一轮循环，k=p，i=1，j=1，已排序数组L、R，比较两数组中最小元素L[i]、R[j]，取较小的置于A[p]，此时子数组A[p..p]不仅是已排序的（仅有一个元素），而且是所有待排序元素中最小的。若最小元素是L[i]，取i=i+1，即i指向L中未排入A的所有元素中最小的一个；同理，j之于R数组也是如此。

保持：若A[p..k]是已排序的，由计算方法知，L中i所指、R中j所指及其后任意元素均大于等于A[p..k]中最大元素A[k],当k=k+1，A[k+1]中存入的是L[i]、R[j]中较小的一个，但是仍有A[k] <= A[k+1]，而此时，子数组A[p..k+1]也必是有序的，i、j仍是分别指向L、R中未排入A的所有元素中最小的一个。

终止： k=r+1时终止跳出循环，此时，A[p..r]是已排序的，且显有A[p] A[p+1] .. A[r]。此即原待排序子数组，故算法正确。

MERGE-SORT(A,p,r)

1 if p<r

2 then q← [(p+r)/2]

3 MERGE-SORT(A,p,r)

4 MERGE-SORT(A,q+1,r)

5 MERGE-SORT(A,p,q,r)

算法与二叉树的后序遍历算法（先左子树，然后右子树，最后根）相似。

（第三行、第四行顺序可以互换）

合并排序算法的C#实现代码：

public static void MergeSort<T>(T[] Input,int p,int r) where T:IComparable<T>

{

int q;

if (p < r)

{

q = (p + r) / 2;

MergeSort(Input, p, q);

MergeSort(Input, q + 1, r);

Merge(Input,p,q,r);

}

}

private static void Merge<T>(T[] Input,int p,int q,int r) where T:IComparable<T>

{

int n1 = q - p + 1;

int n2 = r - q;

T[] L = new T[n1];

T[] R = new T[n2];

for (int i = 0; i < n1; i++)

L[i] = Input[p + i];

for (int j = 0; j < n2; j++)

R[j] = Input[q + 1 + j];

for (int i = 0, j = 0, k = p; k <= r; k++)

{

if(i<n1&&j<n2)

if (L[i].CompareTo(R[j]) < 0||L[i].Equals(R[j]))

{

Input[k] = L[i];

++i;

continue;

}

else

{

Input[k] = R[j];

++j;

continue;

}

if (i >= n1 && j < n2)

{

Input[k] = R[j];

++j;

continue;

}

if (i < n1 && j >= n2)

{

Input[k] = L[i];

++i;

continue;

}

}

}

8.当一个算法中含有对其自身的递归调用时，其运行时间可以用一个递归方程（或递归式）来表示。

合并算法的递归式：

n<=c时,T(n)=Θ(1),否则T(n)=aT(n/b)+D(n)+C(n)

D(n)是分解该问题所用时间，C(n)是合并解的时间；对于合并排序算法，a和b都是2

T(n)在最坏的情况下合并排序n个数的运行时间分析:

当n>1时，将运行时间如下分解：

分解：这一步仅仅算出子数组的中间位置，需要常量时间，因而D(n)=Θ(1)

解决：递归地解为两个规模为n/2的子问题，时间为T(n/2)

合并：含有n个元素的子数组上，MERGE过程的运行时间为C(n) =Θ(n)

n=1时,T(n)=Θ(1),n>1时T(n)=2T(n/2)+ Θ(n)

将上式改写：

n=1时,T(n)=c,n>1时T(n)=2T(n/2)+ cn

在所构造的递归树中，顶层总代价为cn（n个点的集合）。往下每层总代价不变，第i层的任一节点代价为c(n/2^i)（共2^i个节点总代价仍然是cn）。最底层有n个节点（n*1），每个点代价为c。此树共有lgn+1层，深度为lgn。

因此n层的总代价为：cn*(lgn+1)=cnlgn+cn=Θ(nlgn)

练习

2.3-1：2-4为模型，说明合并排序在输入数组A=<3,41,52,26,38,57,9,49>上的执行过程。

(2.3-1

Using Figure 2.4 as a model, illustrate the operation of merge sort on the array A D h3; 41; 52; 26; 38; 57; 9; 49i.)

以文字代替图示

1.(3)(41)→(3,41);(52)(26) →(26,52);(38)(57) →(38,57);(9)(49) →(9,49)

2.(3,41)(26,52) →(3,26,41,52);(38,57)(9,49) →(9,38,49,57)

3.(3,26,41,52)(9,38,49,57) →(3,9,26,38,41,49,52,57)

2.3-2：MERGE过程，使之不适用哨兵元素，而是在一旦数组L或R中的所有元素都被复制回数组A后，就立即停止，再将另一个数组中余下的元素复制回数组A中

(2.3-2

Rewrite the MERGE procedure so that it does not use sentinels, instead stopping

once either array L or R has had all its elements copied back to A and then copying

the remainder of the other array back into A.)

MERGE(A,p,q,r)

1 n1←q-p+n

2 n2←r-p

3 //create arrays L[1..n1] and R[1..n2]

4 for i←1 to n1

5 do L[i] ←A[p+i-1]

6 for j←1 to n2

7 do R[j] ← A[q+j]

8 i←1

9 j←1

10 for k←p to r

11 do if i<n1 and j<n2

12 if L[i]<= R[j]

13 A[k] ← L[i]

14 i←i+1

15 continue

16 else A[k] ← R[j]

17 j←j+1

18 continue

19 do if i>=n1 and j<n2

20 A[k] ← R[j]

21 j←j+1

22 continue

23 do if i<n1 and j>n2

24 A[k] ← L[i]

25 i←i+1

26 continue

2.3-3：利用数学归纳法证明：当n是2的整数次幂时，递归式

这个公式比较难贴上来，看截图吧。

2.3-4：插入排序可以如下改写成一个递归过程：为排序A[1..n]，先递归地排序A[1..n-1]，然后再将A[n]插入到已排序的数组A[1..n-1]中去。对于插入排序的这一递归版本，为它的运行时间写一个递归式。

（2.3-4

We can express insertion sort as a recursive procedure as follows. In order to sort

A[1…n], we recursively sort A[1….n-1] and then insertA[n] into the sorted array

A[1…n-1]. Write a recurrence for the running time of this recursive version of

insertion sort.）

首先是INSERTION过程

INSERTION (A,p,r)

1 for j←p to r

2 do key←A[j]

3 i←j-1

4 while i>0 and A[i]>key

5 do A[i+1] ← A[i]

6 i←i-1

7 A[i+1] ← key

插入排序的递归调用算法：

RECURSION-INSERTION-SORT(A,p,r)

1 if p<r

2 r←r-1

3 RECURSION-INSERTION-SORT(A,p,r)

4 INSERTION(A,p,r)

该算法的C#实现代码：

public static void RecursionInsertionSort<T>(T[] Input,int p,int r) where T:IComparable<T>

{

if (p < r)

{

--r;

RecursionInsertionSort(Input, p, r);

Insertion(Input,p,r);

}

}

private static void Insertion<T>(T[] Input, int p, int r) where T : IComparable<T>

{

T key;

int i;

for (int j = 1; j < r; j++)

{

key = Input[j];

i = j - 1;

for (; i >= 0 && Input[i].CompareTo(key) > 0; i--)

Input[i + 1] = Input[i];

Input[i + 1] = key;

}

}

n<=C时，T(n)=Θ(1),否则T(n)=(n-1)/n*T(n-1)+ Θ(n^2)

2.3-5：回顾一下练习2.1-3中提出的查找问题，注意如果序列A是已排序的，就可以将该序列的中点与v进行比较。根据比较的结果，原序列中有一半就可以不用再做进一步的考虑了。二分查找（binary search）就是一个不断重复这一查找过程的算法，它每次都将序列余下的部分分成两半，并只对其中的一半做进一步的查找。写出二分查找算法的伪代码，可以是迭代的，也可以是递归的。说明二分查找的最坏情况运行时间为什么是Θ(lgn)。

(2.3-5

Referring back to the searching problem (see Exercise 2.1-3), observe that if the

sequence A is sorted, we can check the midpoint of the sequence against _ and

eliminate half of the sequence from further consideration. The binary search algorithm

repeats this procedure, halving the size of the remaining portion of the

sequence each time. Write pseudocode, either iterative or recursive, for binary

search. Argue that the worst-case running time of binary search is Θ(lgn)

使用递归，先确定一个过程BINARY(A,p,r,v)

BINARY(A,p,r,v)

1 for j← p to r

2 if A[j]=v

3 return j

4 return NIL

然后是二分查找的递归过程

BINARY-SEARCH(A,p,r,v)

1 if p=0 and r=0 and A[0]=v

2 return 0

3 if p<r

4 q←[(p+r)/2]

5 if A[q]> v

6 BINARY-SEARCH(A,p,q,v)

7 return BINARY(A,p,q,v)

8 else BINARY-SEARCH(A,q+1,r,v)

9 return BINARY(A,q+1,r,v)

10 return NIL

该算法的C#实现代码：

public static int BinarySearch<T>(T[] Input,int p,int r,T v) where T:IComparable<T>

{

int q;

if (p == 0 && r == 0 && Input[0].Equals(v))

return 0;

if (p < r)

{

q = (p + r) / 2;

if (Input[q].CompareTo(v) > 0 )

{

BinarySearch(Input, p, q, v);

return Binary(Input, p, q, v);

}

else

{

BinarySearch(Input, q + 1, r, v);

return Binary(Input, q+1, r, v);

}

}

return -1;

}

private static int Binary<T>(T[] Input, int p, int r, T v) where T:IComparable<T>

{

for (int j = p; j <= r; j++)

if (Input[j].Equals(v))

return j;

return -1;

}

由公式N=a^(log a N)得：n*1/(2^(lgn))=1

因经过n次的与中点比较后肯定能找到最后一个点（最坏情况了），如果是返回下标，否则返回NIL，故最坏情况下时间复杂度为