一周搞定期末考系列之《算法分析与设计》
转眼就到了期末复习算法的时候了
真的是一点都不慌啊
算法分析与设计这门课，由于是一门选修课，而且我对算法分析没有过多的热爱，所以没有对这门课程进行全方位的深度的学习与复习，但是我相信，将下列算法的全部思想理解清楚后，如果仅仅是为了考试，应该还是不虚的嘿嘿
具体例题思路分析
一、二分搜索(折半查找)
从前有一个故事是这样的，抱着一沓书出图书馆的时候，门响了，在我一本一本的扫描看是那本书没有借的时候，图书馆大妈过来，麻溜的把我的书分成两叠，一堆一堆的扫，然后拿着那本《算法分析与设计》回头看了我一眼，仿佛在说：二分查找都不会？（其实这并不是二分查找嘿嘿）
定义：
优点是比较次数少，查找速度快，平均性能好
缺点是要求待查表为有序表，且插入删除困难
因此，折半查找方法适用于不经常变动而查找频繁的有序列表。
- 假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；
- 否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。
- 重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
时间复杂度：
当第一次选取中间位置时，选取的元素等于所要查找的元素则时间复杂度最短，为O(1)
当在最坏情况下，循环被执行O(logn)次
算法实现：
在这里推荐一下：二分查找有几种写法？它们的区别是什么？
- 回答作者: 胖胖 https://zhihu.com/question/36132386/answer/155438728
在答主的回答里面提到了许多二分算法存在的坑，这也就是为什么说十个二分九个错的原因了嘿
这里我就直接贴上代码了
/**
* Created by Peter Chen on 2017/5/18.
* 常规算法
*/
function firstOccurrence(arrays,target){
var high = arrays.length - 1;
var low = 0;
while(low <= high){
var mid = low + (high - low) / 2;
if(arrays[mid] >= target) high = mid - 1;
if(arrays[mid] < target) low = mid + 1;
}
return low;
}/**
* Created by Peter Chen on 2017/5/18.
* 递归算法
*/
function firstOccurrenceRecur(arrays,target,high,low){
if(low > high) return low;
var mid = low + (high - low) / 2;
if(arrays[mid] >= target)
firstOccurrenceRecur(arrays,target,mid - 1,low);
else{
firstOccurrenceRecur(arrays,target,high,mid + 1);
}
}二、合并排序（归并排序）
定义：
原理：归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
优势：使用它对两个己有序的序列归并，将有无比巨大的优势。其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlogn)，且对数据的有序性不敏感。
缺点：需要与待排序序列一样多的辅助空间，所以数据节点数据量大，则不适合使用
时间复杂度：
最坏时间复杂度 ：O(nlogn)
最好时间复杂度 ：O(nlogn)
空间复杂度 ：O(n)
与快速排序类似
算法实现：
原始数组：{3,8,2,4,1,9,6,5}
初始关键字：[3] [8] [2] [4] [1] [9] [6] [5]
一趟归并后：[3 8] [2 4] [1 9] [5 6]
二趟归并后：[2 3 4 8] [1 5 6 9]
三趟归并后：[1 2 3 4 5 6 8 9]
/**
* Created by Peter Chen on 2017/5/18.
* 自上而下的归并排序
*/
function mergeSort(arr) {
var len = arr.length;
if(len < 2)
return arr;
var mid = Math.floor(len / 2),
left = arr.slice(0,mid),
right = arr.slice(mid);
return merge(mergeSort(left),mergeSort(right));
}
function merge(left,right) {
var result = [];
while(left.length > 0 && right.length > 0){
if(left[0] <= right[0])
result.push(left.shift());
else
result.push(right.shift());
}
while(left.length)
result.push(left.shift());
while(right.length)
result.push(right.shift());
return result;
} 三、快速排序
定义：
原理：快速排序（Quicksort）是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
优势：插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。
缺点：不稳定，在序列有序或者逆序的情况下最不利于发挥其长处
时间复杂度：
快速排序的最坏运行情况是O(n²)
平均期望时间是O(nlog n)
算法实现：
推荐阅读文章：http://developer.51cto.com/art/201403/430986.htm 文章内容非常浅显易懂！！
/**
* Created by Peter Chen on 2017/5/18.
*/
function quickSort(arr,left,right) {
var len = arr.length,
partitionIndex;
left = typeof left != 'number' ? 0 : left;
right = typeof right != 'number' ? len - 1 : right;
if(left < right){
partitionIndex = paitition(arr,left,right);
quickSort(arr,left,partitionIndex - 1);
quickSort(arr,partitionIndex + 1,right);
}
return arr;
}
function partition(arr,left,right) {//分区操作设定基准值
var pivot = left,
index = pivot + 1;
for(i = index;i <= right;i++){
if(arr[i] < arr[pivot]){
swap(arr,i,index);
index++;
}
}
swap(arr,pivot,index - 1);
return index - 1;
}
function swap(arr,i,j) {
var temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}书本算法
template <class Type>
void RandomizedQuickSort(Type a[], int p, int r)//给定数组a,数组起始和终止位置p,r
{
if (p < r) {
int q = RandomizedPartition(a, p, r);//随机选取起始点，此时已排好第一次
RandomizedQuickSort(a, p, q - 1);//对前半部分进行递归排序
RandomizedQuickSort(a, q + 1, r);//对后半部分进行递归排序
}
}
int RandomizedPartition(Type a[], int p, int r) {
int i = Random(p, r);
Swap(a[i], a[p]);//将选出的元素放置到数组头
return Partition(a, p, r);//进行第一次快速排序
}
int Partition(Type a[], int p, int r) {
int i = p, i = r + 1;//给哨兵赋初值
Type x = a[p];//和x进行大小比较
while (true) {
while (a[++i] < x && i < r);//从前找到比X大的
while (a[--j] > x);//从后找到比X小的
if (i >= j) break;//判断两哨兵是否相遇
Swap(a[i], a[j]);//两者交换
}
a[p] = a[j];
a[j] = x;//将比较元素放置数组中间
return j;//返回第一次快速排序中间位置的元素
}四、矩阵连乘（动态规划）
定义：
优化思路： A*B*C = (A*B)C = A（B*C）[即寻找最小乘法数]
条件： 具有优化子结构，具有重叠子问题
时间复杂度：
O(p*q*r)=O(n3)
空间复杂性为O(n3)
算法实现：
思路：建立一个矩阵A[i,j]
每一项m[i,j]=计算Ai~jde 最小乘法数
则m[1,n]=计算A1~n的最小乘法数
m[i,i]=计算Ai~i的最小乘法数
m[i,j]=m[i,k]+m[k+1,j]+pi-1pkpj
五、最长公共子序列（动态规划）
LCS（Longest Common Subsequence）
定义：
一个数列 ，如果分别是两个或多个已知数列的子序列，且是所有符合此条件序列中最长的，则 称为已知序列的最长公共子序列。
时间复杂度：
（i,j）两层循环，i循环m步，j循环n步 复杂度为O(mn)
算法实现：
六、01背包（动态规划）
定义：
你穿越到了神秘海域中，发现了各种各样的宝藏（W1，W2，W3，W4）价值（P1,P2,P3,P4）。但是此时你哥对你说，你只有一个背包（容量为W），怎么样才能把最大价值的东西带回家咧？并且必须带完整的物品（01）。
优化思路：其实说到底，也就是你看见东西往不往包里放而已。
怎么判断呢？当然是放了的价值和不放的价值那个更大，取那个对吧。
状态转移方程为f[i][v]=max{f[i-1][v]（没放）,f[i-1][v-c[i]]+w[i]（放了）}(这件物品的体积是c[i],价值是w[i])
条件：具有优化子结构，具有重叠子问题
时间复杂度：
O(VN)
算法实现：
function max(a, b) {
return (a > b) ? a : b;
}
function dKnapsack(capacity, size, value, n) {
//初始化
var K = [];
for(var i = 0; i <=capacity + 1; i++) {
K[i] = [];
}
//第一层循环商品个数
for(var i = 0; i <= n; i++) {
//第二层循环背包容量
for (var w = 0; w <= capacity; w++) {
if(i == 0 || w == 0) {//初始为0
k[i][w] = 0;
}
else if (size[i - 1] <= w) {//若可以放入则选择较大的放入
K[i][w] = max(value[i - 1] + K[i - 1][w-size[i - 1]],K[i - 1][w]);
}
else {//若无法放下，则不放入
K[i][w] = K[i - 1][w];
}
putstr(K[i][w] + " ");
}
print();
}
return K[n][capacity];
}
//测试
var value = [4, 5, 10, 11, 13];
var size = [3, 4, 7, 8, 9];
var capacity = 16;
var n = 5;
print(dKnapsack(capacity, size, value, n));
七、哈夫曼编码（贪心算法）
定义： 使用变长码根据字符出现的频率进行编码，可以达到文件压缩的效果
前缀码：任意字符的代码都不是其他字符
特点：具有贪心选择性，最优子结构
时间复杂度：
最小堆实现：初始化优先队列需要O（n）,由于最小堆的DeleteMin和Insert运算均需O(logn)时间，n-1次的合并共需要O(nlogn)计算时间，因此，关于n个字符的哈夫曼算法的计算时间为O(nlogn)
算法实现：
template <class Type>
class Huffman {
friend BinaryTree<int> HuffmanTree(Type[], int);
public :
operator Type() const { return weight; }
private:
BinaryTree<int>tree;
Type weight;
};
BinaryTree<int>HuffmanTree(Type f[], int n)
{
//生成单节点树，并初始化
Huffman *w = new Huffman[n + 1];
BinaryTree <int>z, zero;
for (int i = 1; i <= n; i++) {
z.MakeTree(i, zero, zero);
w[i].weight = f[i];
w[i].tree = z;
}
//建立优先队列
MinHeap>Q(1);
Q.Initialize(w, n, n);
//反复合并最小序频率树
Huffmanx, y;
for (int i = 1; i < n; i++) {
Q.DeleteMin(x);
Q.DeleteMin(y);
z.MakeTree(0, x.tree, y.tree);
x.weight += y.weight; x.tree = z;
Q.Insert(x);
}
Q.DeleteMin(x);
Q.Deactivate();
delete[]w;
return x.tree;
} 八、单源最短路径（Dijkstra算法）
定义：
一个指定点到其余各点的最短路径
时间复杂度：
通过矩阵存储有向图边的数据，则时间复杂度为O（N2）
算法实现：
参见我的另外一篇文章：
http://blog.csdn.net/weixin_31347831/article/details/72520615
九、旅行售货员问题
定义：
时间复杂度：
算法实现：
十、最小生成树
定义： 设G=（V，E）是无向连通带权图，即一个网络。E中每条边（v,w）的权为c[v][w]。如果G的一个子图G·是一棵包含了G的所有顶点的数，则称G·为G的生成树。生成树上各边权的总和称为G的最小生成树。
Prim：按照更新顶点Lowcost排序
Kruskal：按照权递增排序
时间复杂度：
Prim算法的时间复杂度为O（n2)
Kruskal算法的时间复杂度在图的边数为e时，为O(eloge)
当e=欧米伽(n2)时，K算法比P算法差，但当e=o(n2)时，Kruskal算法那比Prim算法好
算法实现：
PRIM算法
template
void Prim(int n, Type **c)
{
Type lowcost[maxint];
int closest[maxint];
bool s[maxint];
s[1] = true;
for (int i = 2; i <= n; i++)
{
lowcost[i] = c[1][i];//表示以i为终点的最小权值
closest[i] = 1;//初始化和1相邻
s[i] = false;//都没连接
}
for (int i = 1; i < n; i++) {//重复n-1次，完成算法
Type min = inf;
int j = 1;
for(int k = 2; k <= n;k++)//遍历所有没有连接的点，找出min，并连接
if ((lowcost[k] < min) && (!s[k])) { min = lowcost[k]; j = k; }
cout << j << '' << closest[j] << endl;
s[j] = true;
for(int k = 2;k <=n;k++)//根据连接的点进行更新
if ((c[j][k] < lowcost[k] && (!s[k])) { lowcost[k] = c[j][k]; closest[k] = j; }
}
} Kruskal
class EdgeNode {
friend ostream & operator << (ostream&, EdgeNode<Type>);
friend bool Kruskal(int, int, EdgeeNode<Type>*, EdgeNode<Type>*);
friend void main(void);
public:
operator Type() const { return weight; }
private :
Type weight;
int u, v;
}
bool Kruskal(int n, int e, EdgeNode<Type>E[], EdgeNode<Type> t[])
{
MinHeap<EdgeNode<Type>>H(1);
H.Initialize(E, e, e);
UnionFind U(n);
int k = 0;
while (e && k < n - 1) {//按权递增，找出连接两个不同分支的T1T2中的顶点时，用边形成连通分支
EdgeNode x;
H.DeleteMin(x);
e--;
int a = U.Find(x, u);
int b = U.Find(x, v);
if (a != b) { t[k++] = x; U.Union(a, b); }
}
H.Deactivate();
return (k == n - 1);
}