算法导论 第二章-算法基础
数学归纳法
最简单和常见的数学归纳法是证明当n等于任意一个自然数时某命题成立。证明分下面两步：
证明当n = 1时命题成立。
证明如果在n = k时命题成立，那么可以推导出在n = k+1时命题也成立。（k代表任意自然数
插入排序
插入排序，对有限元素比较合适的算法。和打牌差不多。
伪代码
INSERTION-SORT[A]
for j ← 2 to length[A] // for 循环 j = 2, j < 数组A的length
do key ← A[j] // A[j] 的值 给变量 key
i ← j-1 // i = j - 1
while i > 0 and A[i] >key // 内层循环
do A[i+1] ← A[i]
i ← i-1
A[i+1] ← key
循环不变式用来理解算法的正确性
1.初始化：循环的第一次迭代之前，它为真。
2.保持：如果循环的某次迭代之前它为真，那么下次迭代之前它仍为真。
3.终止：在循环终止时，不变式为我们提供了一个有用的性质，该性质有助于证明算法是正确的
比如一个数组 [1, 22, 3, 4, 44, 55], 跟打牌一样,元素 A[1, j-1] 是手里的牌，[j, n] 是桌上的牌
数学归纳法，要证明某一性质正确，必须首先证明基本情况和一个归纳步骤都是正确的。
归纳法中，归纳步骤是无穷使用的。
就插入排序而言，证明一下。
初始化，当j=2，数组[1…j-1],就1个元素，显然是正确的
保持，证明没一次循环都能让循环不变式成立，在外层循环中，让A[j-1], A[j-2],A[j-3]向右移动，找到A[j]的合适位置。
终止，在j>n时，循环结束了，把j替换为n+1,子数组A[1, n]包含了原来A[1,n]的元素，现在排序好了，他就是整个数组，所以这是正确的。
算法的运行时间，是指在特定的输入时，所执行的基本操作数。
// 插入排序 js版本实现
function insertSort(arr) {
let len = arr.length;
for (let a = 1; a < len; a++) {
// 当前值，当前牌
let cur = arr[a];
let b = a - 1;
// 找到一个合适的位置，把cur插进去
// arr[b] 是排序好的最大的一个，如果这个不大于cur，那就不用排了
while (b > 0 && cur < arr[b]) {
arr[b + 1] = arr[b];
b--;
}
arr[b + 1] = cur;
}
return arr;
}
分析算法
- 分析算法，通常我们想度量的是时间。
- 我们一般假定是单处理器计算模型 RAM作为实现技术，指令一条一条执行，没有并发操作。
- RAM模型，包含真实计算机的指令，如算数指令(加减乘除等)、数据移动指令、控制指令，每条这样的指令需要的时间都是常数。
- 一般来说，算法的时间与输入规模同步增长。所以通常把一个算法的运行时间，描述成输入规模的函数。
- 输入规模的最佳概念依赖于研究的问题。
- 一个算法在特定输入上的运行时间，是执行的基本操作数或者步数。
最坏情况和平均情况分析
对于插入排序的分析。通过具体分析，在最优情况，即数组是排序好的情况下，运行时间可表示为 a*n+b
对于最差的情况，是n2 + b * n + c
在一般情况下，我们是考察算法的最坏运行情况。
增长的量级
运行时间的增长率，或者叫做增长的量级，这样我们只考虑公式的最高次项，以为当n很大，低阶项就不重要了
另外，还要忽略最高次项的常数次数。例如，插入排序的最差时间代价是 Θ(n2)
如果一个算法的最坏运行时间比另外一个低，那么我们认为它的效率更高。
算法设计
插入排序使用的是，增量方法，在排好序的子数组插入元素。
分治法
分治策略是，把原问题划分为n个规模较小，结构与原问题相似的子问题。
递归解决子问题，然后合并结果得到原问题的解。
分治模式，在每一层递归上，都有3个步骤。
- 分解，把原问题划分为子问题。
- 解决，递归解决子问题，子问题足够小则直接解决。
- 合并，子问题的解合并为原问题的解。
以下是归并排序的伪代码
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] = ∞
L[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
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)
归并排序的关键是，合并两个已排序好的子序列。通过一个 MERGE(A,p,q,r) 来实现 p <= q <= r
前提是，子数组 A[p, q] 和 A[q+1, r] 是排序好的数组。通过合并这两个排序好的子数组来代替当前
的子数组 A[p,r];
以下是JavaScript的实现，开始并不好理解，可以打开debugger，一步一步的去看，就比较清晰了
function mergeSort(arr, start, end) {
if (start < end) {
let m = Math.floor((start + end) / 2);
mergeSort(arr, start, m);
mergeSort(arr, m + 1, end);
return merge(arr, start, m, end);
}
}
function merge(arr, start, mid, end) {
/*
这是原书的代码
// 创建左子数组
let n1 = mid - start + 1;
// 创建一个数组，size是子数组的长度+1
let L = new Array(n1 + 1);
for (let i = 0; i < n1; i++) {
L[i] = arr[start + i];
}
// 创建右子数组
let n2 = end - mid;
// 创建一个数组，size是子数组的长度+1
let R = new Array(n2 + 1);
for (let j = 0; j < n2; j++) {
R[j] = arr[mid + j + 1];
}
*/
// js代码可以很简单的实现上边的功能
let L = [...arr.slice(start, mid + 1), Infinity];
let R = [...arr.slice(mid + 1, end + 1), Infinity];
let i = 0, j = 0;
for (let k = 0; k < end - start + 1; k++) {
// debugger
arr[start + k] = L[i] <= R[j] ? L[i++] : R[j++];
}
return arr;
}
分治法分析
当一个算法中含有递归调用时，运行时间可用一个递归方程表示。T(n)
如果问题规模足够小，如 n <= c(常量)，那么表示为O(1)
把原问题分解为a个子问题，每个问题规模是原问题的 1/b, 分解问题是D(n) ,合并问题是C(n)
那么 T(n) = aT(n/b) + D(n) + C(n)
归并算法的分析
分解，需要常量时间 D(n) = O(1)
解决, 递归解决两个规模是n/2的子问题，时间是2T(n/2)
合并，合并n的元素的子数组，merge时间是O(n), 所以C(n) = O(n)
所以带入 T(n) = aT(n/b) + D(n) + C(n) 就是
T(n) = 2T(n/2) + O(n) + O(n)
T(n) = 2T(n/2) + O(n)
我们用常数c代表O(1),于是得到 T(n) = 2T(n/2) + cn
递归树总的层数是 lgn+1 ，每一层的代价是 cn
所以 T(n) = cn(lgn+1) = nlgn