算法(Algorithm )是一组用于处理数据和解决程序问题的方法。 对于同一问题，使用不同的算法可能最终得到的结果相同，但流程消耗的资源和时间差异很大。
那么我们应该如何衡量算法之间的优劣呢？
还是从算法占有的“时间”和“空间”两个维度来考虑。
时间维：执行当前算法所需的时间，通常用“时间复杂性”表示。 “区域”是运行当前算法所需的内存空间，通常称为“区域复杂性”。 因此，评价一个算法的效率主要是看其时间复杂度和空间复杂度的状况。 但是，有时时间和空间在“鱼和熊掌”上不能兼顾，所以有必要取得平衡。
分别介绍“时间复杂性”和“空间复杂性”的计算方法。
时间复杂度首先，时间复杂度的计算不是计算程序具体执行的时间，而是算法执行语句的次数。
如果我们前面有多个算法，通过计算时间的复杂性，可以判断哪个算法在具体执行上花的时间最多，花的时间最少。
一般时间的复杂性如下
阶次o(1)、对数阶次o(log2n )、线性阶次o(log2n )、线性对数阶次o(log2n )、平方阶次o(n ) 2、立方阶次o(n^k) k次幂次o(n^k )、指数阶次o (2^ n )。 随着n的增大，时间复杂度变大，算法需要时间。
计算方法
选择相对增长最快的项目
最高项系数均为1
常数时用o(1)表示
例如f(n )=2*n^3) 2n100
o(n )=n^3。
通常我们计算时间复杂度都是计算最坏情况
时间复杂度例题1. 常数例题的时间复杂度
int x=90； int y=100； while(y0 ) if ) x100 ) { x=x - 10； y----； (else ) x； }这个代码只有常数，所以时间的复杂性只有o(1)
2. for循环的时间复杂度
for(I=1； i=n； I () j=I； j； }所有这些代码都可以用o(n )来表示时间的复杂性，因为for循环中的代码执行n次，并且消耗的时间随n的变化而变化。
嵌套循环的时间复杂度for(I=0； i n； I ) for(j=0； j i； j ) for(k=0； k j； k () x； }}有多个循环时，时间复杂度由嵌套层数最多的循环语句中最内层的频率决定。 时间复杂度： o(n^3) ) ) ) ) ) )。
求二分法时间复杂度的intselect(inta[(]，int k，int len ) ) intleft=0； int right=len - 1； while(left=right ) intmid=left ) (right-left )2)； if(a[mid]==k ) { return 1； }elseif(a[mid]k ) ) { right=mid - 1； } else { left=mid 1； } }返回空值； }
最坏情况循环x次后，n/(2^x )=1； x=log2n；
因此，二分搜索的时间复杂度是o(log2n )
空间复杂度空间复杂度是一种算法在运行中临时占用存储空间大小的度量。
计算方法：
忽略常数，用o(1)表示
递归算法的空间复杂度=递归深度N*每次递归所需的辅助空间
对于单线程，递归具有运行时堆栈，并确定递归最深堆栈占用的空间数。 因为递归最深的堆栈占用的空间足以容纳其所有递归过程。
空间复杂度例题1. 常数
intfun(intn，) {int k=10； if(n==k )返回n； else返回函数(n； }递归实现，调用fun函数，每次创建一个变量k。 被调用n次，空间复杂度o(n*1)=o (n ) ) ) ) ) ) ) ) ) ) 652
2. 实现二分查找算法的递归及非递归
#define _CRT_SECURE_NO_WARNINGS#include<stdio.h>#include<string.h>#include<assert.h>int BinarySearch(int arr[], int len, int num){ assert(arr); int left = 0; int right = len - 1; int mid; while (left <= right) { mid = left + (right - left) / 2; if (num > arr[mid]) { left = mid + 1; } else if (num < arr[mid]) { right = mid - 1; } else { return mid; } } return -1;}int main(){ int arr[] = { 1,2,3,4,5,6,7,8,9 }; int length = sizeof(arr) / sizeof(arr[0]); int aim = 9; int result; result = BinarySearch(arr, length, aim); if (result == -1) { printf("Can't find %dn", aim); } else { printf("%d at %d postionn", aim,result + 1); } return 0;}二分查找时，每次都在原有查找内容进行二分，所以时间复杂度为O（log2 n）
因为变量值创建一次，所以空间复杂度为O（1）
3. 递归算法
int BinarySearchRecursion(int arr[5], int lef, int rig,int aim){ int mid = lef + (rig - lef) / 2; if (lef <= rig) { if (aim < arr[mid]) { rig = mid - 1; BinarySearchRecursion(arr, lef, rig, aim); } else if (arr[mid] < aim) { lef = mid + 1; BinarySearchRecursion(arr, lef, rig, aim); } else if (aim == arr[mid]) { return mid; } } else return -1;}int main(){ int arr[] = { 1,2,3,5,6, }; int sz = sizeof(arr)/sizeof(arr[0]); int result; result = BinarySearchRecursion(arr, 0, sz - 1, 4); if (-1 == result) { printf("Can't find it.n"); } else printf("Aim at %d locationn", result+1);}时间复杂度为O（log2 n）
每进行一次递归都会创建变量，所以空间复杂度为O（log2 n）