《算法导论》读书笔记--第二章 2.3 设计算法
我们可以使用的算法设计技术有很多。插入排序用的是增量方法，即在已经排好的数组中不断加入新的元素。下面考虑一种被称为“分治法”的设计方法。
2.3.1分治法
分治法的思想：将原问题分解为几个规模较小但是类似于原问题的子问题，递归地求解这些子问题，然后合并这些子问题的解来建立原问题的解。分治模式在每层递归时有三个步骤：
分解原问题为若干子问题；
解决这些子问题，递归地求解各子问题，若子问题规模足够小，则直接求解；
合并这些子问题的解成原问题的解。
归并排序算法完全遵循分治模式，操作如下：
分解：分解待排序的n个元素的序列成各具n/2个元素的两个子序列；
解决：使用归并排序递归地排序两个子序列；
合并：合并已经排序的子序列以产生已排序的答案。
当被排序的序列长度为1时，递归“开始回升”。
下面写出合并这一步的伪代码，时间复杂度为theta(n).
//MERGE 伪代码 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、左右两个子序列分别递增，在哪一个子列选出一个数，这个序列下标加1；
3、为了不用每次确认子序列是否为空，要在子序列的最后放一张“哨兵牌”，这张牌非常大，当碰到这张牌时，一定是另一个序列的数被选出，当两个子序列都到达“哨兵牌”时，此时恰好所有数都存进原数组了（由循环头的迭代数目控制）；在左右序列的长度不一致时，哨兵牌才会发挥威力，两个子序列长度一样的时候，同时达到最后一张牌，那么“哨兵牌”就没什么作用了；
4、另外注意的是，需要开辟新的数组来存储每个子序列，注意下标的确认，尤其是计算子序列长度时不要弄错。
下面我们把MERGE作为归并排序的一个子程序，下面是MERGE-SORT的伪代码：
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)
注意点：
1、为了排序A[p,...,r]，首先要调用MERGE-SORT(A,1,A.length);
2、然后不断分解A；
3、在到了基本情况的时候，“向上回滚”，不断将子序列进行合并，知道将n个数全部合并好为止；
4、十分要注意的是分治算法的分解和合并过程（这里还需要进行详细分析）；
5、实际上，归并算法并“没有”排序的显示过程，算法在不断分解数组，直到基础情况，再进行合并，这个合并的过程中才有“排序”的过程。
//归并排序c++代码
#include <iostream> #include <time.h> const int MAX = 1e6; void MERGESORT(int*, int,int); void MERGE(int*,int,int,int); using namespace std; int main() { clock_t start, end; start = clock(); int i; int* arr = new int[100]; for (i = 0; i < 100; i++) { arr[i] = 100 - i; } MERGESORT(arr,0,99); for (i = 0; i < 100; i++) { cout << arr[i] << " "; if (i % 10 == 9) { cout << "\n"; } } delete[]arr; cout << "__________________" << endl; end = clock(); cout << "Run time: " << (double)(end - start) / CLOCKS_PER_SEC << "s" << endl; return 0; } void MERGESORT(int* a, int p, int r) { int q; if (p < r) //这里不能有等号，否则会进入死循环的，你猜我怎么知道的？ { q = (p + r) / 2; MERGESORT(a, p, q); MERGESORT(a, q + 1, r); MERGE(a, p, q, r); } } void MERGE(int* arr, int p, int q, int r) { int n1 = q - p + 1; int n2 = r - q; int* Left = new int[n1 + 1]; int* Right = new int[n2 + 1]; int i, j; for (i = 0; i < n1; i++) Left[i] = arr[p + i]; for (j = 0; j < n2; j++) Right[j] = arr[q + j + 1]; Left[n1] = MAX; Right[n2] = MAX; i = 0; j = 0; for (int k = p; k <= r; k++) { if (Left[i] <= Right[j]) { arr[k] = Left[i]; i++; } else { arr[k] = Right[j]; j++; } } delete []Left; delete []Right; }
2.3.2 分析分治算法
当一个算法包含对其自身的递归调用时，我们往往可以用递归方程或递归式来描述其运行时间，该方程根据在较小输入上的运行时间来描述在规模为n的问题上的总运行时间。
分治算法运行时间的递归式来自基本模式的三个步骤。若问题规模足够小，比如对某个常量c，n<=c，则直接求解需要常量时间，记为theta(1)。假设原问题分解为a个子问题，每个子问题的规模是原问题的1/b(注意：这里的a和b不一定相等)。若分解子问题需要时间为D(n)，合并子问题的解成原问题的解需要时间C(n)，则得到递归式：
归并排序算法的分析
假定n是2的幂，为了简便可以将n设为2的次幂，我们将看到这样的假设不影响递归式解的增长量级。假定归并一个元素需要常量时间。当n>1个元素时，我们分解运行时间如下：
分解：分解步骤仅仅计算子数组的中间位置，需要常量时间；
解决：递归地求解两个规模均为n/2的子问题，将贡献2T(n/2)的运行时间；
合并：一个具有n个元素的数组，MERGE过程时间复杂度为theta(n)，记为C(n)=theta(n)。
给出最坏情况运行时间T(n)的递归式：
我们已有将证明T(n)=theta(nlgn)，注意这里的lgn代表以2为底的对数函数。可以用递归树的方法也可以证明其复杂度。
既然想开了用截图，那么递归树也来愉快地截图吧……
