一.算法效率
算法效率分析分为两种：第一种是时间效率，第二种是空间效率。时间效率被称为时间复杂度，而空间效率被称作空间复杂度。 时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间，在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。
二.时间复杂度
1.时间复杂度的概念
时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。
2.大 o的渐进表示法
实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。
大O符号（Big O notation）：是用于描述函数渐进行为的数学符号.
推导大O阶方法：
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。
// 请计算一下Func1基本操作执行了多少次？
void Func1(int N)
{
int count = 0; // 1次
for (int i = 0; i < N; ++i)
{
for (int j = 0; j < N; ++j)
{
++count; // N*N次
}
}
for (int k = 0; k < 2 * N; ++k)
{
++count; // 2*N次
}
int M = 10;
while (M--)
{
++count; // 10次
}
printf("%d\n", count); // 1次
}
Func1 执行的基本操作次数 ：
F(N) = N*N + 2 * N + 12
使用大O的渐进表示法以后，Fun1的时间复杂度为 O(N^2)
通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。
另外有些算法的时间复杂度存在最好、平均和最坏情况：
最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数(下界)
例如：在一个长度为N数组中搜索一个数据x
最好情况：1次找到
最坏情况：N次找到
平均情况：N/2次找到
在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)
3.常见时间复杂度的计算
(1).
// 计算Func2的时间复杂度？
void Func2(int N)
{
int count = 0; // 1次
for (int k = 0; k < 2 * N; ++k)
{
++count; // 2 * N次
}
int M = 10; // 1次
while (M--)
{
++count; // 10次
}
printf("%d\n", count); // 1次
}
Func2 执行的基本操作次数 ：
F(N) = 2 * N + 13
使用大O的渐进表示法以后，Fun1的时间复杂度为 O(N)
(2).
// 计算Func3的时间复杂度？
void Func3(int N, int M)
{
int count = 0; // 1次
for (int k = 0; k < M; ++k)
{
++count; // M次
}
for (int k = 0; k < N; ++k)
{
++count; // N次
}
printf("%d\n", count); // 1次
}
Func2 执行的基本操作次数 ：
F(N) = M + N + 2
使用大O的渐进表示法以后，Fun1的时间复杂度为 O(M + N)
(3).
// 计算Func4的时间复杂度？
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++k)
{
++count;
}
printf("%d\n", count);
}
因为执行次数为常数，由第一条规则:
用常数1取代运行时间中的所有加法常数
可知时间复杂度为: O(1)
(4).
// 计算BubbleSort的时间复杂度？
void BubbleSort(int* arr, int n)
{
assert(arr); // 1次
int i = 0; // 1次
for (i = 0; i < n - 1; i++)
{
int flag = 0; // n - 1次
int j = 0; // n - 1次
for (j = 0; j < n - 1 - i; j++)
{
if (arr[j] > arr[j + 1]) // 1 + 2 +3 + ....+ n - 1次
{
int tmp = arr[j]; // 1 + 2 +3 + ....+ n - 1次
arr[j] = arr[j + 1]; // 1 + 2 +3 + ....+ n - 1次
arr[j + 1] = tmp; // 1 + 2 +3 + ....+ n - 1次
flag = 1; // 1 + 2 +3 + ....+ n - 1次
}
}
if (flag == 0)
break;
}
}
考虑最坏的情况，数据为降序，将其排为升序
BubbleSort 执行的基本操作次数 ：
F(N) = 2 * n^2 + n
使用大O的渐进表示法以后，BubbleSort 的时间复杂度为 O(n^2)
考虑最好的情况，数据本来就是升序，只需要进行最内层循环 j 从 0 到 n - 1，进行 n - 1 比较,之后检查出有序，即可退出整个循环
复杂度为 O(n)
(5).
// 计算BinarySearch的时间复杂度？
int BinarySearch(int* a, int n, int x)
{
assert(a);
int begin = 0;
int end = n - 1;
while (begin <= end)
{
int mid = begin + ((end - begin) >> 1);
if (a[mid] < x)
begin = mid + 1;
else if (a[mid] > x)
end = mid - 1;
else
return mid;
}
return -1;
}
因为二分查找每次排除掉一半的不适合值，所以对于n个元素的情况：
一次二分剩下：n/2
两次二分剩下：n/2/2 = n/4
…
m次二分剩下：n/(2^m)
在最坏情况下是在排除到只剩下最后一个值之后得到结果，所以为
n/(2^m)=1;
2^m=n;
m = log2^n
而在数据结构中常常这样写lgn,所以时间复杂度为O(lgn);
(6).
// 计算阶乘递归Factorial的时间复杂度？
long long Factorial(size_t N)
{
return N < 2 ? N : Factorial(N - 1) * N;
}
递归算法的时间复杂度计算方法:
递归的次数 * 每次递归函数内操作的次数
求N的阶乘需要递归 N 次，每次递归函数内操作 1 次，因此时间复杂度为 O(N)
(7).
// 计算斐波那契递归Fibonacci的时间复杂度？
long long Fibonacci(size_t N)
{
return N < 2 ? N : Fibonacci(N-1)+Fibonacci(N-2);
}
总结点数 = 斐波那契数列数列执行次数
若为满二叉树，则执行次数为:
2^0 + 2^1 + 2^ 2 + …+ 2^(n - 1) = 2^n - 1
我们可以发现在图中越靠右的部分越先停止调用,因此执行次数会比满二叉树的情况少，但当N足够大时，这些少执行的部分影响微乎其微。
而且我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，由大O的渐进表示法可知时间复杂度为O(2^n)