算法导论第二章读书笔记

November 14, 2019 13390

插入排序

伪代码
1
2
3
4
5
6
7
8
9
INSERTION-SORT(A)
for j=2 to A.length
  key = A[j]
  //insert A[j] into the sortes sequence A[1...j-1]
  i = j-1
  while i>0 and A[i]>key
    A[i+1] = A[i]
    i = i-1
  A[i+1] = key
javascript实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
function insertion_sort(arr) {
  var key = 0;
  var i = 0;
  for(var j = 1; j < arr.length; j++) {
    key = arr[j];
    i = j - 1;
    while (i >= 0 && arr[i] > key) {
      arr[i+1] = arr[i];
      i = i - 1;
    }
    arr[i+1] = key;
  }
  return arr;
}

循环不变式

初始化：循环第一次迭代之前，它为真
保持：如果循环的某次迭代之前它为真，那么下次迭代之前它仍为真
终止：在循环终止时，不变式为我们提供一个有用的性质，该性质有助于证明算法是正确的

算法分析

INSERTION-SORT(A) 代价 次数
for j=2 to A.length c1 n
key = A[j] c2 n-1
//insert A[j] into the sortes sequence A[1...j-1] 0 n-1
i = j-1 c4 n-1
while i>0 and A[i]>key c5 ∑tj (2<=j<=n)
A[i+1] = A[i] c6 ∑(tj - 1) (2<=j<=n)
i = i-1 c7 ∑(tj - 1) (2<=j<=n)
A[i+1] = key c8 n-1

tj 表示对那个值j第5行执行while循环测试的次数
所以，T(n) = c1n + c2(n-1) + c4(n-1) + c5∑tj (2<=j<=n) + c6∑(tj - 1) (2<=j<=n) + c7∑(tj - 1) (2<=j<=n) + c8(n-1)
最佳情况：对j=2, 3, …, n，有tj = 1，所以 T(n) = (c1 + c2 + c4 + c5 +c8)n - (c2 + c4 + c5 + c8) = Θ(n)
最坏情况：对j=2, 3, …, n，有tj = j，所以 ∑tj (2<=j<=n) = ∑j (2<=j<=n) = n(n+1)/2 - 1, ∑(tj - 1) (2<=j<=n) = n(n-1)/2, T(n) = (c5 + c6 + c7)n^2/2 + (c1 + c2 + c4 + c5/2 - c6/2 - c7/2 + c8)n - (c2 + c4 + c5 + c8) = Θ(n^2)

归并排序算法

分治模式

分治模式在每层递归时都有三个步骤：
分解原问题为若干个子问题，这些字问题是原问题的规模较小的实例。
解决这些子问题，递归地求解各子问题。然而，若子问题的规模足够小，则直接求解。
合并这些子问题的解成原问题的解。

归并排序

归并排序算法完全遵循分治模式。直观上其操作如下：
分解：分解待排序的n个元素的序列成各具n/2个元素的两个子序列。
解决：使用归并排序递归地排序两个子序列。
合并：合并两个已排序的子序列以产生已排序的答案。

通过调用一个辅助过程MERGE(A, p, q, r)来完成两个已排序序列的合并，其中A是一个数组，p、q和r是数组下标，满足 p<=q<r。该过程假设子数组A[p..q]和A[q+1..r]都已排好序。它合并两个子数组形成单一的已排好序的子数组并代替当前的子数组A[p..r]。

伪代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
MERGE(A, p, q, r)
  n1 = q - p + 1
  n2 = r - q
  Let L[1..n1+1] and R[1..n2+1] be new arrays
  for i = 1 to n1
    L[i] = A[p + i - 1]
  for j = 1 to n2
    R[j] = A[q+j]
  //插入哨兵牌
  L[n1 + 1] = ∞
  R[n2 + 1] = ∞
  i = 1
  j = 1
  for k = p to r
    if L[i] <= R[j]
      A[k] = L[i]
      i = i + 1
    else A[k] = R[j]
      j = j + 1
1
2
3
4
5
6
MERGE-SORT(A, p, r)
if p < r
  q = └(p + r)/2┘
  MERGE-SORT(A, p, q)
  MERGE-SORT(A, q + 1, r)
  MERGE(A, p, q, r)

分析分治算法

分治算法运行时间的递归式来自基本模式的单个步骤。假设T(n)是规模为n的一个问题的运行时间。若问题规模足够小，如对某个常量c，n<=c，则直接求解需要常量时间，将其记作Θ(1)。假设把原问题分解成a个子问题，每个子问题的规模是原问题的1/b。为了求解一个规模为n/b的子问题，需要T(n/b)的时间，所以，需要aT(n/b)的时间来求解a个子问题，如果分解问题成子问题需要时间D(n)，合并子问题的解成原问题的解需要C(n)，那么得到递归式：
若n<=c，T(n) = Θ(1)；其他，T(n) = aT(n/b) + D(n) + C(n)

所以，归并排序的最坏情况运行时间T(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
对递归式T(n) = 2T(n/2) + cn构造递归树，如下：
所以，T(n) = Θ(nlgn)

练习

2.1-2 重写INSERTION-SORT，使之按非升序排列

1
2
3
4
5
6
7
8
INSERTION-SORT2(A)
for j=2 to A.length
  key = A[j]
  i = j-1
  while i > 0 and A[i] < key
    A[i+1] = A[i]
    i = i-1
  A[i+1] = key
1
2
3
4
5
6
7
8
9
10
11
12
13
14
function insertion_sort2(arr) {
  var key = 0;
  var i = 0;
  for(var j = 1; j < arr.length; j++) {
    key = arr[j];
    i = j - 1;
    while (i >= 0 && arr[i] < key) {
      arr[i+1] = arr[i];
      i = i - 1;
    }
    arr[i+1] = key;
  }
  return arr;
}

2.1-3 考虑一下查找问题：
输入：n个数的一个序列 A=<a1, a2, …, an> 和一个值v
输出：下标i是的 v=A[i] 或者当v不在A中出现时，v为特殊值NIL
写出线性查找的伪代码，它扫描整个序列来查找v。使用一个循环不变式来证明你的算法是正确的。确保你的循环不变式满足三条必要的性质。

1
2
3
4
5
LINEAR-SEARCH(A, v)
for i=1 to A.length
  if A[i] equals v
    return i
return NIL
1
2
3
4
5
6
7
8
function linear_search(arr, v) {
  for(var i = 0; i < arr.length; i++) {
    if (arr[i] === v) {
      return i+1;
    }
  }
  return null;
}

2.1-4 考虑把两个n位二进制整数加起来的问题，这两个整数分别存储在两个n元数组A和B中。这两个整数的和应按二进制形式存储在一个(n+1)元数组C中。请给出该问题的形式化描述，并写出伪代码。
输入：两个n元数组A和B
输出：一个(n+1)元数组C 

1
2
3
4
5
6
7
8
9
BINARY-ADD(A, B)
for i=A.length to 1
    tmp = A[i] + B[i] + tmp;
  if tmp > 1
    C[i+1] = tmp - 2
    tmp = 1
  else C[i+1] = tmp
        tmp = 0
C[1] = tmp      
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function binary_add(arr1, arr2) {
  var arr3 = [];
  var tmp = 0;
  for(var i = arr1.length-1; i >= 0; i--) {
    tmp = arr1[i] + arr2[i] + tmp;
    if (tmp > 1) {
      arr3[i+1] = tmp - 2;
      tmp = 1;
    }
    else {
      arr3[i+1] = tmp;
      tmp = 0;
    }
  }
  arr3[0] = tmp;
  return arr3;
}

2.2-1 用Θ记号表示函数n^3/1000-100n^2-100n+3
Θ(n^3)

2.2-2 考虑排序存储在数组A中的n个数：首先找出A中的最小元素并将其与A[1]中的元素进行交换。接着，找出A中的次最小元素并将其与A[2]中的元素进行交换。对A中前n-1个元素按该方式继续。这算法称为选择算法，写出其伪代码。该算法维持的循环不变式是什么？为什么它只需要对前n-1个元素，而不是对所有n个元素运行？用Θ记号给出选择排序的最好情况与最坏情况运行时间

1
2
3
4
5
6
7
8
9
10
SELECTION(A)
for j=1 to A.length-1
  min = A[j]
  pointer = j
  for i=j to A.length
    if A[i] < min
      min = A[i]
      pointer = i
  A[pointer] = A[j]
  A[j] = min    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function selection(arr) {
  var min = 0;
  var pointer = 0;
  for(var j = 0; j < arr.length - 1; j++) {
    min = arr[j];
    pointer = j;
    for(var i = j; i <arr.length; i++) {
      if (arr[i] < min) {
        min = arr[i];
        pointer = i;
      }
    }
    arr[pointer] = arr[j];
    arr[j] = min;
  }  
  return arr;
}

因为第n个元素在进过前n-1个循环后一定是最大的，所以不需要对它在进行操作。
Θbest = Θ(n^2)
Θworest = Θ(n^3) Θ(n^2)

2.2-3 再次考虑线性查找问题（参见练习2.1-3）。假定要查找的元素等可能地为数组中的任意元素，平均需要检查的输入序列的多少元素？最坏情况又如何？用Θ记号给出线性查找的平均情况和最坏情况运行时间。证明你的答案
平均情况 T(n) = 1/(n+1) + 2/(n+1) + 3/(n+1) + … + n/(n+1) + n/(n+1) = (n^2 + 3n)/2(n+1) = Θ(n)
最坏情况 T(n) = Θ(n)

2.3-2 重写过程MERGE，使之不使用哨兵，而是一旦数组L或R的所有元素均被复制回A就立刻停止，然后把两一个数组的剩余部分复制回A

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
MERGE2(A, p, q, r)
n1 = q - p + 1
n2 = r - q
let L[1..n1] and R[1.. n2] be new arrays
for i = 1 to n1
  L[i] = A[p + i - 1]
for j = 1 to n2
  R[j] = A[q + j]
i = 1
j = 1
for k = p to r
  if (L[i] <= R[j] or j > n2)
    A[k] = L[i]
    i = i + 1
  else if (L[i] > R[j] or i > n1)
    A[k] = R[j]
    j = j + 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
var arr = [10,7,3,9,2,9,4,5,6,11];
function merge2(p, q, r) {
  var n1 = q - p + 1;
  var n2 = r - q;
  var arrL = [];
  var arrR = [];
  var i = 0, j = 0;
  for (i = 0; i < n1; i++) {
    arrL[i] = arr[p + i];
  }
  for (j = 0; j < n2; j++) {
    arrR[j] = arr[q + j + 1];
  }
  i = 0;
  j = 0;
  var k = 0;
  for (k = p; k < r + 1; k++) {
    if (arrL[i] <= arrR[j] || j >= n2) {
      arr[k] = arrL[i];
      i = i + 1;
    } else if (arrL[i] > arrR[j] || i >= n1) {
      arr[k] = arrR[j];
      j = j + 1;
    }
  }
}
function merge_sort(p, r) {
  var mid = 0;
  if (p < r) {
    mid = Math.floor((p + r)/2);
    merge_sort(p, mid);
    merge_sort(mid+1, r);
    merge2(p, mid, r);
  }
}
merge_sort(0, arr.length-1);
console.log(arr);

2.3-4 我们可以把插入排序表示为如下的一个递归过程。为了排序A[1..n]，我们递归地排序A[1..n-1]，然后把A[n]插入到已排序的数组A[1..n-1]。为插入排序的这个递归版本的最坏情况运行时间写一个递归式
如果n = 1，T(1) = 1；
如果n > 1，将A[n]插入A[1..n-1]需要比进行n-1次比较，所以 T(n) = T(n-1) + c(n-1)

2.3-5 回顾线性查找问题，注意到，如果序列A已排好序，就可以将该序列的中点与v进行比较。根据比较的结果，原序列中有一半就可以不用再做进一步的考虑了。二分查找算法重复这个过程，每次都将序列剩余部分的规模减半。为二分查找写出迭代或递归的伪代码。证明：二分查找的最坏运行时间为Θ(lgn)

1
2
3
4
5
6
7
8
9
10
11
12
BINARY-SEARCH(A, key)
start = 1
end = A.length
while (start <= end)
  i = └(start + end) / 2┘
  if (A[i] == key)
    return i
  else if (A[i] > key)
    end = i - 1
  else if (A[i] < key)
    start = i + 1
return "NF"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function binary_search(array, key) {
  var start = 0, end = array.length-1;
  var i = 0;
  while (start <= end) {
    i = Math.floor((start + end)/2);
    if (array[i] === key) {
      return i;
    } else if (array[i] > key) {
      end = i - 1;
    } else if (array[i] < key) {
      start = i + 1;
    }
  }
  return "NF";
}

如果n = 1，T(1) = 1；
如果n > 1, 最差的情况就是比较到最后一位，得出结论，所以T(n)=lgn

2.3-6 注意插入排序的第5~7行的while循环采用一种线性查找来（反向）扫描已排好序的子数组A[1..j-1]。我们可以使用二分查找来把插入排序的最坏情况运行总时间改进到Θ(nlgn)吗？

1
2
3
4
5
6
7
8
INSERTION-SORT2(A)
for i=2 to A.length
    newA = A.slice(0,1)
    key = A[i]
    answer = BINARY-SEARCH(newA, key)
    for j=i down to answer
      A[j] = A[j-1]
    A[answer] = key
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
function binary_search(array, key) {
  var start = 0, end = array.length-1;
  var i = 0;
  while (start <= end) {
    i = Math.floor((start + end)/2);
    if (array[i] === key) {
      return i;
    } else if (array[i] > key) {
      end = i - 1;
    } else if (array[i] < key) {
      start = i + 1;
    }
  }
  return (start < end)? end: start;
}
function insertion_sort2(array) {
  for (var i = 1; i < array.length; i++) {
    var new_array = array.slice(0, i);
    var key = array[i];
    var answer = binary_search(new_array, key);
    for(var j = i; j > answer; j--) {
      array[j] = array[j-1];
    }
    array[answer] = key;
  }
  return array;
}

2.3-7 描述一个运行时间为Θ(nlgn)的算法，给定n个整数的集合S和另一个整数x，该算法能确定S中是否存在两个其和刚好为x的元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
function determineSumX(array, x) {
  var filtered = array.filter(function(e) {
    return e<x;
  });
  var sorted = insertion_sort2(filtered);
  var start = 0, end = sorted.length-1;
  while(start < end) {
    if (sorted[start] + sorted[end] === x) {
      return true;
    } else if (sorted[start] + sorted[end] < x) {
      start = start + 1;
    } else if (sorted[start] + sorted[end] > x) {
      end = end - 1;
    }
  }
  return false;
}
function binary_search(array, key) {
  var start = 0, end = array.length-1;
  var i = 0;
  while (start <= end) {
    i = Math.floor((start + end)/2);
    if (array[i] === key) {
      return i;
    } else if (array[i] > key) {
      end = i - 1;
    } else if (array[i] < key) {
      start = i + 1;
    }
  }
  return (start < end)? end: start;
}
function insertion_sort2(array) {
  for (var i = 1; i < array.length; i++) {
    var new_array = array.slice(0, i);
    var key = array[i];
    var answer = binary_search(new_array, key);
    for(var j = i; j > answer; j--) {
      array[j] = array[j-1];
    }
    array[answer] = key;
  }
  return array;
}

2.1 （在归并排序中对小数组采用插入排序）虽然归并排序的最坏情况运行时间为Θ(nlgn)，而插入排序的最坏运行时间为Θ(n^2)，但是插入牌组中的常量因子可能使得它在n较小时，在许多机器上实际运行得更快。因此，在归并排序中，当子问题变得足够小时，采用插入排序来使递归的叶变粗是有意义的。考虑对归并排序的一种修改，其中使用插入排序来排序长度为k的n/k个子表，然后使用标准的合并机制来合并这些子表，这里k是一个待定的值。
a. 证明：插入排序最坏的情况可以在Θ(nk)时间内排序每个长度为k的n/k个子表。
b. 表明在最坏的情况下如何在Θ(nlg(n/k))时间内合并这些子表。
c. 假定修改后的算法的最坏情况运行时间为Θ(nk+nlg(n/k))，要使修改后的算法与标准的归并排序具有相同的运行时间，作为n的一个函数，借助Θ记号，k的最大值是什么？
d. 在实践中，我们应该如何选择k？
a. 因为插入排序的最坏运行时间为Θ(n^2)，所以对于长度为k的1个子表，最坏运行时间为Θ(k^2)；
又因为一共有n/k个子表，所以，最坏运行时间为(n/k)*Θ(k^2) = Θ(nk)。
b. 由结果递归树可得，最小的叶子节点为cn/k，共有k个叶子节点，所以树的高度为lg(n/k)，又每层将贡献总代价cn，所以，总代价为cn(lg(n/k)+1)，也就是Θ(nlog(n/k))。
c. Θ(nk + nlg(n/k)) = Θ(nlgn)，=>Θ(k+lg(n/k)) = Θ(lgn)，所以k<lgn，k的最大值应该是lgn。
d. 这是个实验问题，应该在k的合法范围内测试可能的k，用T-INSERTION-SORT(k)表示k个元素的插入排序时间，T-MERGE-SORT(k)表示k个元素的合并排序时间。该问题等价于测试求解T-INSERTION-SORT(k)/T-MERGE-SORT(k)比值最小的k值。

2.2 （冒泡排序算法的正确性）冒泡排序算法是一种流行但低效的排序算法，它的作用是反复交换相邻的未按次序排列的元素。

1
2
3
4
5
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′表示BUBBLESORT(A)的输出。为了证明BUBBLESORT正确，我们必须证明它将终止并且有：
A’[1] ≤ A’[2] ≤ … ≤ A’[n] (2.3)
其中 n=A.length。为了证明BUBBLESORT确实完成了排序我们还需要证明什么？
下面两个部分将证明不等式（2.3）。
b. 为第24行的for循环精确地说明一个循环不变式，并证明该循环不变式成立。你的证明应该使用本章中给出的循环不变式证明的结构。
c. 利用在(b)部分证明的循环不变式的终止条件，为第14行的for循环说明一个循环不变式，它可以用来证明不等式(2.3)。你的证明应采用本章中给出的循环不变式的证明结构。
d. 冒泡排序算法的最坏情况运行时间是多少？与插入排序的运行时间相比，其性能如何？
a. 当n=1时，能够正确排序。
b. 对第24行的for循环，循环不变式是A[j]是子数组A[j…n]中的最小值，且子数组中的元素并未改变。约定：n=A.length。
初始化：开始时，j=n，子数组中只包含A[n]，故循环不变式成立
保持：假设对于任意的一个j，使得A[j]是子数组A[j…n]中的最小值，在下一轮循环中，若A[j] < A[j-1]，则A[j]和A[j-1]交换。使得A[j-1]是子数组A[j-1…n]中的最小值，循环不变式依然成立
终止：循环结束时j=i，A[j]是子数组A[j…n]中的最小值，且子数组中的元素并未改变。
c. 对于14行的for循环，循环不变式是每次循环前，A[1…i-1]中包含了整个数组中前i-1小的排好序的元素，而A[i…n]中包含剩下的元素。 
初始化：第一次循环前i=1，子数组为空，循环不变式成立
保持：假设对于任意一个i，使得A[1…i-1]中包含了整个数组中前i-1小的排好序的元素，而A[i…n]中包含剩下的元素，则内层循环保证了A[i]是子数组A[i…n]中的最小元素，则A[1…i]中包含了整个数组中前i小的排好序的元素，而A[i+1…n]中包含剩下的元素。循环不变式成立
终止：循环结束时i=n+1，则A[1…n]中包含了整个数组中前n小的排好序的元素，即数组有序。
d. 冒泡排序最坏和最好运行时间均为Θ(n^2)
插入排序的最坏运行时间为Θ(n^2)，但是最好运行时间为Θ(n)
排序前A所有元素已经有序时，插入排序达到最好运行时间。

2.3 （霍纳(Horner)规则的正确性）给定系数a0, a1, …, an和x的值，代码片段

1
2
3
1　y = 0
2　for i = n downto 0
3　　　y = ai + x·y

实现了用于求值多项式
 
的霍纳规则。
a. 借助Θ记号，实现霍纳规则的以上代码片段的运行时间是多少？
b. 编写伪代码来实现朴素的多项式求值算法，该算法从头开始计算多项式的每个项。该算法的运行时间是多少？与霍纳规则相比，其性能如何？
c. 考虑以下循环不变式：
在第2～3行for循环每次迭代的开始有 把没有项的和式解释为等于0。遵照本章中给出的循环不变式证明的结构，使用该循环不变式来证明终止时有
d. 最后证明上面给出的代码片段将正确地求由系数a0, a1, …, an刻画的多项式的值。
Answer:
a. Θ(n)
b. 伪代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
MERGE(A, p, q, r)
n1 = q - p + 1
n2 = r - q
Let L[1..n1+1] and R[1..n2+1] be new arrays
for i = 1 to n1
    L[i] = A[p + i - 1]
for j = 1 to n2
    R[j] = A[q+j]
//插入哨兵牌
L[n1 + 1] = ∞
R[n2 + 1] = ∞
i = 1
j = 1
for k = p to r
    if L[i] <= R[j]
        A[k] = L[i]
        i = i + 1
    else A[k] = R[j]
        j = j + 1
        count = count + 1