《算法导论》练习与思考题第1-3章 (python版)

第一章 算法在计算中的作用

练习

1.1 算法

1.1-1

排序的例子：一个医生要接诊的病人会按照挂号时间排序。

1.1-2

热效率，衡量发动机等热能转换装置能量利用的效率

1.1-3

数据结构：链表
优势：顺序访问效率高
局限：随机访问效率低

1.1-4

相似之处：都是点与点之间的移动；都是求最短的移动路线
不同：最短路径问题有明确的解法，而旅行商问题是NP完全问题，没有有效算法。

1.1-5

必须是最佳解的例子：一个数学定理的证明
可以使用近似解的例子：手术方案的建立

1.2 作为一种技术的算法

1.2-1

应用层的例子：一个压缩软件，在应用层就会使用压缩算法。
算法的功能：应该将输入的数据无损地转换为更小的数据

1.2-2

当n的取值为2-6时插入排序优于归并排序

1.2-3

n最小为15时在同一台机器上$100n^2$的算法优于$2^n$的算法

思考题

1-1 运行时间的比较

思路：先将给定时间转换为毫秒，然后用$f(n)$的逆函数求出对应的n值

	1秒钟（1000ms）	1分钟（60000ms）	1小时（3600000ms）	1天(86400000ms)	1月(2592000000ms)	1年(31536000000ms)	1世纪(3153600000000ms)
$\lg n$	$10^{1000}$	$10^{60000}$	$10^{3600000}$	$10^{86400000}$	$10^{2592000000}$	$10^{31536000000}$	$10^{3153600000000}$
$\sqrt{n}$	$1000^2$	$60000^2$	$3600000^2$	$86400000^2$	$2592000000^2$	$31536000000^2$	$3153600000000^2$
$n$	$1000$	$60000$	$3600000$	$86400000$	$2592000000$	$31536000000$	$3153600000000$
$n^2$	$31$	$244$	$1897$	$9295$	$50911$	$177583$	$1,775,837$
$n^3$	$10$	$39$	$153$	$442$	$1373$	$3159$	$14,664$
$2^n$	$9$	$15$	$21$	$26$	$31$	$34$	$41$
$n!$	$6$	$8$	$9$	$11$	$12$	$13$	$15$

第二章 算法基础

练习

2.1 插入排序

2.1-1

2.1-2

def insertionSortNonAscending(A):
	for j in range(1,len(A)):
		key = A[j]
		i = j - 1
		while i >=0 and A[i] < key:
			A[i+1] = A[i]
			i -= 1
		A[i+1] = key

2.1-3

def linearFind(A, v):
	for j in range(len(A)):
		if A[j] == v:
			return j
	return None

循环不变式：已经搜索的子数组A[0…j-1]中不存在v

• 初始化：迭代开始之前(当0=1时)子数组A[0…j-1]中一个元素也没有，循环不变式成立
• 保持：如果A[j]等于v，循环终止。反之A[0…j]中不存在v，循环不变式成立
• 终止：当j等于A.length时循环终止，此时已经搜索的子数组A[0…j-1]即原数组A[0…n]。而如果在循环中A[j]等于v时循环终止，此时前一次迭代已经搜索的子数组A[0…j-1]中没有v，循环不变式成立

2.1-4

二进制加法问题：
     输入：n个数的两个序列，$A=<a_1,a_2,\cdots ,a_n>$和$B=<b_1,b_2,\cdots ,b_n>$,A和B表示两个二进制数每个数位的依次排列
     输出： n+1个数的序列$C=<c_1,c_2,\cdots ,c_{n+1}>$，C为二进制数A与B的和

def binarySum(A, B):
	carry = 0
	C = []
	for i in range(len(A)-1,-1,-1):
		sum = A[i] + B[i] + carry
		C.insert(0, sum % 2)
		carry = sum // 2 
	C.insert(0, carry)
	return C

2.2 分析算法

2.2-1

$\Theta (n^3)$

2.2-2

def selectionSort(A):
	for i in range(len(A)-1):
		min = i
		for j in range(i+1,len(A)):
			if A[min] > A[j]:
				min = j
		A[min],A[i]=A[i],A[min]

循环不变式：A[0…i-1]为已排序好的序列
考虑最后一次循环，此时i=n-1，A[1…n-2]为已排序的序列且都小于A[n-1]和A[n]，当将A[n]和A[n-1]中最小的放到A[n-1]处时，A[n]处的数据也回到了正确的位置，所以只循环n-1次就足够。
最好情况和最坏情况都是$\Theta (n^2)$的运行时间

2.2-3

平均情况和最坏情况运行时间均为$\Theta (n)$。
证明：
平均情况时，假设v有n+1种情况，v等可能的出现在A中任一位置或者不出现。
所以平均的运行时间为$\frac{1+2+\cdots +n}{n+1}=\frac{\frac{1}{2}n(n+1)}{n+1}=\frac{1}{2}n=\Theta (n)$
最坏情况时不出现，总共循环比较n次，运行时间为$\Theta (n)$。

2.2-4

？？？不太确定题的意思
大概是保证最好情况时循环能够直接结束程序给出答案吧。

2.3 设计算法

2.3-1

2.3-2

def merge(arr, p, q, r):
    n1 = q - p + 1
    n2 = r - q
    L = arr[p:q + 1]
    R = arr[q + 1:r + 1]
    i = j = 0
    k = p
    while i < n1 and j < n2:
        if L[i] <= R[j]:
            arr[k] = L[i]
            i += 1
        else:
            arr[k] = R[j]
            j += 1
        k += 1
    while i < n1:
        arr[k] = L[i]
        k += 1
        i += 1
    while j < n2:
        arr[k] = R[j]
        k += 1
        j += 1

2.3-3

首先：当k=1时$n=2^k=2$，$T(n)=T(2)=2,n\lg n=2$，所以$T(n)=n\lg n$
假设：k=m时等式成立，$n=2^m,T(n)=n\lg n=m{2}^m$。因此k=m+1时将$n=2^{m+1}$带入$T(n)=2T(\frac{n}{2})+n$中，得$T(n)=2T(2^m)+2^{m+1}=m{2}^{m+1}+2^{m+1}=(m+1)2^{m+1}$，而$n\lg n=2^{m+1}\lg (2^{m+1})=(m+1)2^{m+1}$,所以$T(n)=n\lg n$成立
综上所述，当n刚好是2的幂时，本题递归式的解为$T(n)=n\lg n$

2.3-4

$$T(n)=\{\begin{array}{ll}\Theta (1),& n=1\\ T(n-1)+\Theta (n),& n>1\end{array}$$

2.3-5

def binaryFind(A, v, p, q):
    if p <= q:
        r = (p + q) // 2
        if A[r] == v:
            return r
        elif A[r] < v:
            return binaryFind(A, v, r + 1, q)
        else:
            return binaryFind(A, v, p, r - 1)
    else:
        return None

最坏情况下，有如下递归式：
$$T(n)=\{\begin{array}{ll}\Theta (1),& n=1\\ T(\frac{n}{2})+\Theta (1),& n>1\end{array}$$
显然有：
$$\lg n\{\begin{array}{l}T(n)-T(\frac{n}{2})=\Theta (1)\\ T(\frac{n}{2})-T(\frac{n}{2^2})=\Theta (1)\\ T(\frac{n}{2^2})-T(\frac{n}{2^3})=\Theta (1)\\ \cdots \cdots \\ T(2)-T(1)=\Theta (1)\end{array}$$
所以最坏情况的运行时间为$\Theta (\lg n)$

2.3-6

不能，2.1节中INSERTION-SORT的while循环同时起到两个作用：找到已排序的n个数中要插入的位置和将该位置之后的元素向后移动一位，运行时间是$\Theta (n)$。最坏情况时，找到位置的需求可以使用二分查找来降低运行时间为$\Theta (\lg n)$，但移动元素的运行时间还是$\Theta (n)$，所以while循环的运行时间无法通过使用二分查找降低至$\Theta (\lg n)$，所以最坏情况运行时间也无法使用二分查找改进到$\Theta (n\lg n)$的运行时间。

2.3-7

使用归并排序将集合的元素排序，时间复杂度为$\Theta (n\lg n)$，假设排好序的元素组成序列$A=<a_1,a_2,\cdots ,a_n>$，其中$a_1⩽a_2⩽\cdots ⩽a_n$。从数列两端遍历，让left=$a_1$,right=$a_n$，考虑left+right和x的关系。假设此时left=$a_l$,right=$a_r$
如果left+right==x，说明正好找到了题目要求的两个数。
如果left+right>x，那么right右边的所有数$a_{r^{\prime }}$都有left$+a_{r^{\prime }}>$left$+a_r>$x。此时将right左移一位，重新判断。
如果left+right<x，那么left左边的所有数$a_{l^{\prime }}$都有$a_{l^{\prime }}+$right$>a_l$+right$>$x。此时将left右移一位，重新判断。
当left和right重叠时说明已经找遍了可能产生x的两个数的组合。
可以看出，最好情况一次找到时间复杂度为$\Theta (1)$，最坏情况会遍历一遍排序完的序列，时间复杂度为$\Theta (1)\times n=\Theta (n)$，但无论什么情况显然远远小于$\Theta (n\lg n)$的排序时间，所以该算法的时间复杂度为$\Theta (n\lg n)$。

思考题

2-1

a.插入排序n个元素的最坏情况时间复杂度为$\Theta (n^2)$。所以$\frac{n}{k}$个子表插入排序的时间复杂度为$\Theta (k^2)\times \frac{n}{k}=\Theta (nk)$

b.归并两个长度为k的子表时间复杂度为$\Theta (k)$，归并$\frac{n}{k}$个子表时间复杂度为$\Theta (k)\times \Theta (\frac{n}{k})=\Theta (n)$，可知每轮归并时间复杂度为$\Theta (n)$，$\frac{n}{k}$个子表需要归并$\Theta (\lg (\frac{n}{k}))$轮，所以合并子表最坏情况时间复杂度为