算法导论第三版第六章思考题

6-1

a.

不一样。例如习题6.3-1中的数组A，如果采用BUILD-MAX-HEAP算法得到的最大堆为$A_1=\{84,22,19,10,3,17,6,5,9\}$；但如果采用插入方法建堆，得到的最大堆是$A_2=\{84,22,19,17,10,5,6,3,9\}$

b.

在最坏的情况下，A应该是一个依次增大的有序数组，则每次MAX-HEAP-INSERT操作的复杂度为$Theta(lgi)$，一共$n-1$次插入操作，所以时间复杂度为

$$\sum_{i=2}^n lgi=lg(n!)=\Theta(nlgn)$$

6-2

a.

求父节点下标：
PARENT(i)
1 return $\lfloor i/d\rfloor$
求第$k(1\le k\le d)$个子节点下标：
CHILD(i, k)
1 return $d \cdot i + k - 1$

b.

含$n$个元素的$d$叉堆高度是$\lfloor lg_dn\rfloor$

c.

EXTRACT_MAX(A)
1 if A.heap-size < 1
2   error "heap underflow"
3 max = A[1]
4 A[1] = A[A.heap-size]
5 A.heap-size = A.heap-size - 1
6 MAX-HEAPIFY(A,1)
7 return max

其中MAX-HEAPIFY(A,i)为：

MAX-HEAPIFY(A,i)
1 largest = i
2 for j = 1 to d
3   if CHILD(i,j) <= A.heap-size and A[j] > A[i]
4     largest = j
5 if largest 不等于 i
6   exchange A[i] with A[CHILD(i,largest)]
7   MAX-HEAPIFY(A, largest)

MAX-HEAPIFY函数的时间复杂度为$O(lg_dn)$，所以EXTRACT-MAX的时间复杂度也为$O(lg_dn)$。

d.

INSERT(A, key)
1 A.heap-size = A.heap-size + 1
2 A[A.heap-size] = -infty
3 INCREASE-KEY(A, A.heap-size, key)

其中INCREASE-KEY(A, i, key)为：

INCREASE-KEY(A, i, key)
1 if key < A[i]
2   error "new key is smaller than current key"
3 while i > 1 and A[PARENT(i)] < A[i]
4   exchange A[i] with A[PARENT(i)]
5   i = PARENT(i)
6 A[i] = key

其中HEAP-INCREASE-KEY函数的复杂度为$O(lg_dn)$，所以INSERT函数的复杂度也为$O(lg_dn)$

e.

INCREASE-KEY的实现如上题。时间复杂度为$O(lg_dn)$

6-3

a.

$$\begin{matrix} 2 &3&4&\infty\\5&8&9&\infty\\12&14&16&\infty\\\infty&\infty&\infty&\infty\end{matrix}$$

b.

因为对一个$m*n$的Young氏矩阵Y，每一行都从左到右排列，每一列都从上到下排列，所以第一行第一个，也就是$Y[1,1]$是整个矩阵最小的元素，最后一行最后一个，也就是$Y[m,n]$是整个矩阵最大的数。故如果$Y[1,1]=\infty$，说明最小的数也为空，整个$Y$就为空；如果$Y[m,n]\lt \infty$，说明最大的数也存在，故$Y$为满的。

c.

EXTRACT-MIN(Y)
1 min = Y[1, 1]
2 Y[1, 1] = infty
3 i = 1, j = 1
4 while true
5   if j < n and Y[i, j + 1] < Y[i, j]
6     exchange Y[i, j + 1] with Y[i, j]
7     j = j + 1
8   else if i < m and Y[i + 1, j] < Y[i, j]
9     exchange Y[i + 1, j] with Y[i, j]
10    i = i + 1

$T(p)$的递归表达式为：

$$T(p) = T(p - 1) + O(1) = O(p)=O(m+n)$$

d.

INSERT(Y, key)
1 Y[m, n] = key
2 i = m, j = n
3 while true
4   if j > 1 and Y[i, j - 1] < Y[i, j]
5     exchange Y[i, j - 1] with Y[i, j]
6     j = j - 1
7   if i > 1 and Y[i - 1, j] < Y[i, j]
8     exchange Y[i - 1, j] with Y[i, j]
9     i = i - 1

e.

逐次使用EXTRACT-MIN函数从$Y$矩阵中取出最小数，一共需要进行$n^2$次，每次时间复杂度为$O(n+n)= O(n)$，所以总的算法时间复杂度为$O(n^3)$

f.

COMPARE(Y, key)
1 i = m, j = 1
2 while true
3   if j < n and Y[i, j] < key
4     j = j + 1
5   else if Y[i, j] == key
6     return true
7   else if i > 1 and Y[i, j] > key
8     i = i - 1
9 return false