标签：
1. 从【插入排序】说起
插入排序（insert-sort）在生活中的一个应用场景就是玩扑克时，右手（不考虑左撇子）不断从桌上拿起一张扑克，按大小插入到左手的扑克序列的相应位置中。在结束时，左手的扑克是排好序的。
算法很简单，下面直接给出java实现代码：
/** * 插入排序 * * @param a 需要排序的数组 */ public static void insertSort(int[] a) { for (int i = 1; i < a.length; i++) { int j = i - 1; // curr 表示要插入的扑克 int curr = a[i]; // 要插入的扑克从左手的扑克序列最右端不断向左移动 // 直到到了尽头或者要插入的扑克比左手某一扑克大时，就停止移动 while (j > -1 && curr < a[j]) { a[j + 1] = a[j]; j--; } a[j + 1] = curr; } }
2. 理论证明
在以上程序中，每轮循环结束（外层for循环）时，a[0~i]（表示a数组的0~i位）都是排好序的，我们把a[0~i]的这一性质形式地表示为一个循环不变式。
循环不变式可用来帮助我们理解算法的正确性：
循环第一次迭代之前，它为true；
如果循环迭代式某次迭代之前它为true，那么下次迭代之前它也为true；
在循环终止时，不变式为我们提供一个有用的性质，该性质有助于证明算法是正确的；
应用以上理论来验证以上的算法是否正确：
因此算法是正确的。
3. 算法分析
我们假定一种通用的单处理器计算模型——随机访问机（random-access machine，RAM）来作为实现技术的模型。在该模型中，一些常用的计算机指令，包括算术指令（加、减、乘、除、取余、向上取整、向下取整）、数据移动指令（装入、储存、复制）和控制指令（条件与无条件转移、子程序调用与返回），它们执行所需的时间为常量。
还是以上面的插入排序（insert-sort）为例来说明：
//(c, n)，第一个参数表示该步执行一次的时间，第二个参数表示该步执行的次数。 for (int i = 1; i < a.length; i++) { // (c1, n) int j = i - 1; //(c2, n-1) int curr = a[i]; // (c3, n-1) while (j > -1 && curr < a[j]) { // (c4, t2+t3+...+tn) a[j + 1] = a[j];// (c5, (t2-1)+(t3-1)+...+(tn-1)) j--;// (c6, (t2-1)+(t3-1)+...+(tn-1)) } a[j + 1] = curr;// (c7, n-1) }
计算总时间：
最佳情况：T(n) =c1 * n + c2 * (n - 1) + c3 * (n - 1) + c4 * (n - 1) + c7 * (n - 1)= (c1 + c2 + c3 + c4 + c7) * n – (c2 + c3 + c4 + c7)
我们把T(n)表示为an+b，它是n的线性函数。
最坏情况：T(n) = c1 * n + (c2 + c3 + c7) * (n - 1) + c4 * [n(1 + n) / 2 - 1] + (c5 + c6) * [n(1 + n) / 2] = (c4 / 2 + c5 / 2 + c6 / 2) * n² + (c1 + c2 + c3 + c7 - c4 / 2 - c5 / 2 - c6 / 2) * n – (c2 + c3 + c7 + c4)
我们把T(n)表示为an^2 + bn + c，它是n的二次函数。
做更近一步的简化抽象，我们真正感兴趣的是运算时间的增长率（增长量级）。因此忽略低阶项和最高阶项的常系数。记插入排序（insert-sort）的最佳情况运行时间为：θ(n)，最坏情况运行时间为：θ(n²)。
对于插入排序（insert-sort），我们更应该考虑的是最坏情况，因为：① 最坏情况给出了一个上界，可以确保该算法不会超过某一时间；② 最坏情况往往经常出现；③ “平均情况”和最坏情况大致一样差。
4. 算法设计
插入排序（insert-sort）采用了增量方法，将a[i]插入子数组a[0~i-1]中，子数组增长为：a[0~i]。
下面介绍一种叫做分治法（Divide and Conquer）的设计方法：将原问题分解为几个规模较小的但类似于原问题的子问题，递归的解决这些子问题，然后合并这些子问题的解来建立原问题的解。
归并排序（merge-sort）完全遵循分治法（Divide and Conquer），操作步骤如下：
下面给出归并排序（merge-sort）的java实现代码：
/** * 将a[p~r]排序 * * @param a * @param p * @param r */ public static void mergeSort(int[] a, int p, int r) { if (p < r) { int q = (r + p) / 2; mergeSort(a, p, q); mergeSort(a, q + 1, r); merge(a, p, q, r); } } /** * 合并2个已排序的序列(a[p ~ q]和a[q+1 ~ r]) * * @param a * @param p q >= p * @param q * @param r */ public static void merge(int[] a, int p, int q, int r) { int[] a1 = new int[q - p + 2]; int[] a2 = new int[r - q + 1]; for (int i = 0; i < a1.length - 1; i++) { a1[i] = a[p + i]; } a1[a1.length - 1] = Integer.MAX_VALUE; for (int i = 0; i < a2.length - 1; i++) { a2[i] = a[q + i + 1]; } a2[a2.length - 1] = Integer.MAX_VALUE; int m = 0, n = 0; for (int i = p; i < r + 1; i++) { if (a1[m] < a2[n]) { a[i] = a1[m]; m++; } else { a[i] = a2[n]; n++; } } }
下面分析分治法（Divide and Conquer）：
设T(n)为规模为n的问题运用分治法所需的运行时间。若问题规模足够小，如对于某个常量c，n <= c，则直接求解需要常量时间，记为：θ(1)；否则，把问题分解成a个子问题，每个子问题的规模是原来的1 / b，则T(n) = a * T(n / b)，如果分解为子问题所需时间为D(n) （可记为：θ(1)），合并子问题所需的时间为C(n)（可记为：θ(n)），那么T(n)递归式为：
特别的，对于归并排序（merge-sort），
可以求得，当n-> ∞时，T(n) = c * n * lg n + cn，记为：θ(n * lg n)。
可见当n较大时，在最坏情况下，归并排序（merge-sort）优于插入排序（insert-sort）。
ps：以上内容均摘自《算法导论》中文译本。本人只是提取出文中个人认为比较重要的点，加入了一些个人理解，仅供参考。有些句子和词由于是翻译过来的，所以可能比较突兀，会意就好。
标签：
原文地址：http://www.cnblogs.com/dongkuo/p/4782669.html
