《算法导论》学习笔记之Chapter 2-2.1,2.2,2.3插入排序，选择排序，归并排序

本来想写所谓的学习笔记，想来想去还是觉得直接记录自己在学习过程中编写的代码更靠谱。下面就闲话少说，参考文中给的伪代码，用自己熟悉的语言实现。

1：插入排序

public void InsertSort(int[] a) {for (int i = 1; i < a.length; i++) {int k = a[i];int j = i - 1;while (j >= 0 && a[j] >= k) {a[j + 1] = a[j];j--;}//此处为什么是j+1，不是j，需要注意：是因为j在while循环中已经先减去1了。可画图助于理解。a[j + 1] = k;}}

上边的代码，是按照升序排序。如果按照非升序排序，则修改a[j] > k 为 a[j] <= k

插入排序，最好的时间是O（n），此时数组已排好序；最坏的情况时间是O（n.^2），此时数组反向排序；综合来说，插入排序算法的时间复杂度为O（n.^2）。

下面是一个习题：计算两个二进制数相加的函数：

public static void BinaryAdd(int[] a, int[] b) {int c[] = new int[5];int len = a.length;int flag = 0;for (int i = len - 1; i >= 0; i--) {int temp = a[i] + b[i] + flag;if (temp < 2) {c[i+1] = temp;flag = 0;} else {c[i+1] = 0;flag = 1;}}c[0] = flag;}

下面是习题2.2-2，考察选择排序：

public static void SelectSort(int[] a) {for (int i = 0; i < a.length - 1; i++) {int smallest = a[i];int k = i;for (int j = i + 1; j < a.length; j++) {if (a[j] <= smallest) {smallest = a[j];k = j;}}a[k] = a[i];a[i] = smallest;}}

我是按照递增顺序排列的，需要注意的是：

a[k] = a[i];a[i] = smallest;

我最初编写的时候，没注意，写成了：

a[i] = smallest;

a[k] = a[i];

虽然只是顺序反了，猛一看没啥区别，其实差别大了，你会丢失掉原来的a[i]值。关于2.2-3习题的线性查找问题，将其与二分查找相比较分析一下：线性查找 针对所有数组：有序，无序；二分查找主要针对有序数组；线性查找：查找次数平均为N/2.二分查找：查找次数在10位的数组中最大数为4（运气好的好，也许第一次就找到了）。基数小时，二者差别不明显；当基数增大时：线性查找次数将会成正比增长，K=N/2；而二分查找，我们通过一个公式来表达，K=㏒2(N),对数计算给出了二分查找法最大耗费的次数。那么N/2与㏒2(N)对比之下，差异性就显现了。
2.3节考察分而治之的算法：归并排序。我实现的代码如下：

public void MergeSort(int[] a, int p, int r) {if (p < r) {int q = (p + r) / 2;MergeSort(a, p, q);MergeSort(a, q + 1, r);Merge(a, p, q, r);}}public static void Merge(int[] a, int p, int q, int r) {int n1 = q - p + 1;int n2 = r - q;int[] L = new int[n1];int[] R = new int[n2];for (int i = 0; i < n1; i++) {L[i] = a[p + i];}for (int j = 0; j < n2; j++) {R[j] = a[q + j + 1];}int i = 0;int j = 0;int k = p;while (i < n1 && j < n2) {if (L[i] < R[j]) {a[k] = L[i];k++;i++;} else {a[k] = R[j];k++;j++;}}while (i < n1) {a[k] = L[i];k++;i++;}while (j < n2) {a[k] = R[j];k++;j++;}}

上面的代码，我觉得写得已经非常的清晰了，相信以后就算淡忘了，应该也能轻易看懂。其实，就是逐渐拆分大问题，然后分而治之，之后再合并小问题。其中，有些地方还可以简化编写形式，如：

a[k] = R[j];
k++;
j++;
可以直接简化为：a[k++] = R[j++];

分治算法的时间复杂度符合这个公式：
            T(n) = aT(n/b) + D(n) + C(n)
其中T(n/b)是被分解成a份，每份为n/b的子问题的求解时间； D(n)为分解问题的时间；C(n)为合并子问题的时间；

针对归并排序算法，最坏的运行情况：
分解仅仅计算子数组的中间值，所以D(n)=θ(1);
而合并过程则需要C(n)=θ(n)的时间；
中间解决所需时间为两个规模为n/2的子问题时间2T(n/2);
最后T(n) = 2T(n/2) + θ(n);  （θ(1)被忽略）

归并排序对n个数进行排序，分解树有logn+1层（从最顶层n个分解到最底层每个节点为1个），每一层代价为cn，所以，归并排序总的时间代价函数为cn*(logn+1)， θ(nlogn)。

参照这个过程，二分查找最坏的运行时间为θ(logn)，分解过程是一样的，区别在于二分查找每次仅比较1个值；