算法之【时间复杂度】与【空间复杂度】
目录
一、算法
1、算法定义
2、两种算法的比较
3、算法的特性
4、算法设计的要求
二、算法的复杂度
1、时间复杂度
1.1定义
1.2大O的渐近表示法
1.3推导大O阶方法
1.4最坏情况与平均情况
1.5常见的时间复杂度计算示例
常数阶：
线性阶：
对数阶：
平方阶：
2、空间复杂度
一、算法
1、算法定义
算法就是定义良好的计算过程，它取一个或一组的值为输入，并产生出一个或一组的值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。概括起来就是数据结构是在内存当中存储、管理数据；算法是对各种数据进行处理，怎么处理就看我们自己的需求了。
2、两种算法的比较
现在要求写一个求1+2+3+······+100结果的程序，大多数人会马上写出下面的C语言代码：
#include
int main()
{
int i;
int sum = 0;
int n = 100;
for (i = 1; i <= 100; i++)
{
sum += i;
}
printf("%d\n", sum);
return 0;
} 这是最简单的计算机程序之一，它就是一种算法，但这种算法是最高效的吗？
这个时候，我们就得将伟大的数学家高斯的童年故事拿来说一遍。据说18世纪生于德国小村庄的高斯，上小学的一天，课堂很乱，老师就非常生气，于是在放学时，就要求每个学生都计算1+2+···+100的结果，谁先算出来谁先回家。天才当然不会被这样的问题难倒，高斯很快就得出了答案，是5050。老师非常惊讶，因为他自己想必也是通过1+2=3，3+3=6，······4950+100=5050这样算出来的，也算了很久很久。可是，眼前这个少年，一个上小学的孩子，为何可以这么快的得出结果？高斯解释道：
sum = 1 + 2 + 3 + ... + 99 + 100
sum = 100 + 99 + 98 + ... + 2 + 1
2 * sum = 100 + 101 + 101 + ... + 101 + 101 (共100个)所以sum = 5050
用程序实现如下：
#include
int main()
{
int sum = 0;
int n = 100;
sum = (1 + n) * n / 2;
printf("%d\n", sum);
return 0;
} 高斯的方法相当于一种求等差数列的算法，不仅仅可以用于1加到100，就是加到1千，1万，1亿，也就是瞬间之事。但如果用第一种挨个加的程序，显然计算机要循环1千，1万，1亿次的加法运算。
3、算法的特性
算法具有五个基本特性：输入、输出、有穷性、确定性和可行性。
输入输出：
算法具有零个或多个输入，至少有一个或多个输出。
有穷性：
指算法在执行有限的步骤之后，自动结束而不会出现无限循环，并且每一个步骤在可接受的时间内完成。
确定性：
算法的每一步骤都具有确定的含义，不会出现二义性。
可行性：
算法的每一步都必须是可行的，也就是说，每一步都能够通过执行有限次数完成。
4、算法设计的要求
好的算法设计有四个要求：正确性、可读性、健壮性、时间效率高和存储量低。
正确性：
算法的正确性是指算法至少应该具有输入、输出和加工处理无歧义性，能正确反映问题的需求，能够得到问题的正确答案。
可读性：
算法设计的另一目的是为了方便阅读、理解和交流。
健壮性：
当输入数据不合法时，算法也能做出相关处理，而不是产生异常或莫名其妙的结果。
时间效率高和存储量低：
时间效率指的是算法的执行时间，执行时间短的算法效率高，执行时间长的效率低；存储量需求指的是算法在执行过程中需要的最大存储间，主要指算法程序运行时所占用的内存或外部硬盘存储空间。
二、算法的复杂度
算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源。因此衡量一个算法的好坏，一般是从时间和空间两个角度来衡量的，即时间复杂度和空间复杂度。
时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。在计算机发展的早期，计算机的存储容量很小，所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要在特别关注一个算法的空间复杂度。
1、时间复杂度
1.1定义
在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是都可以上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例。算法中的基本操作的执行次数，为算法的时间复杂度。即找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。
1.2大O的渐近表示法
我们先来看一段代码，请计算一下Func1中++count语句总共执行了多少次？
void Func1(int N)
{
int count = 0;
for (int i = 0; i < N; ++i)
{
for (int j = 0; j < N; ++j)
{
++count;
}
}
for (int k = 0; k < 2 * N; ++k)
{
++count;
}
int M = 10;
while (M--)
{
++count;
}
printf("%d\n", count);
}Func1 执行的基本操作次数：F(N) = N^2 + 2*N + 10
- 实际中我们计算时间复杂度时，其实并不一定要计算精确的执行次数，而只需要计算大概执行次数，那么这里我们使用大O的渐进表示法。
- 大O符号（Big O notation）：是用于描述函数渐进行为的数学符号 。
1.3推导大O阶方法
- 用常数1取代运行时间中的所有加法常数。
- 在修改后的运行次数函数中，只保留最高阶项。
- 如果最高阶项存在且其系数不是1，则去除与这个项相乘的系数。
得到的结果就是大O阶。
上面的代码使用大O渐进法以后，Func1的时间复杂度为：O(N^2)
1.4最坏情况与平均情况
通过上面的代码示例我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。另外有些算法的时间复杂度存在最好、平均和最坏情况：
最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数(下界)
例如：我们在一个长度为N的数组中查找某个数字：
最好情况：1次找到
最坏情况：N次找到
平均情况：N/2次找到
在实际中一般在没有特殊说明的情况下，关注的都是算法的最坏运行情况，即最坏时间复杂度，所以数组中搜索数据时间复杂度为O(N)。
1.5常见的时间复杂度计算示例
常数阶：
int sum = 0，n = 100;//执行一次
sum = (1 + n) * n / 2;//执行一次
printf("%d\n", sum);//执行一次这个算法的运行次数函数是f(n) = 3。根据我们推导大O阶的方法，第一步就是把常数项3改为1。在保留最高项阶时发现，它根本没有最高阶项，所以这个算法的时间复杂度为O(1)。
另外，我们试想一下，如果这个算法当中的语句sum = (1 + n) * n / 2有10句，即：
int sum = 0, n = 100;//执行1次
sum = (1 + n) * n / 2;//执行第1次
sum = (1 + n) * n / 2;//执行第2次
sum = (1 + n) * n / 2;//执行第3次
sum = (1 + n) * n / 2;//执行第4次
sum = (1 + n) * n / 2;//执行第5次
sum = (1 + n) * n / 2;//执行第6次
sum = (1 + n) * n / 2;//执行第7次
sum = (1 + n) * n / 2;//执行第8次
sum = (1 + n) * n / 2;//执行第9次
sum = (1 + n) * n / 2;//执行第10次
printf("%d\n", sum);//执行1次事实上无论n为多少，上面的两段代码就是3次执行和12次执行的差异。这种与问题的大小（n的大小）无关，执行时间恒定的算法，我们称之为具有O(1)的时间复杂度，又叫常数阶。
注意：不管这个常数是多少，我们都记作O(1)，而不能是O(3)、O(12)等其它任何数字。
线性阶：
线性阶的循环结构会复杂很多。要确定某个算法的阶次，我们常常需要确定某个特定语句或某个语句集运行的次数。因此，我们要分析算法的复杂度，关键就是要分析循环结构的运行情况。
int i;
for (i = 0; i < n; i++)
{
}上面这段代码，循环体中的代码需要执行n次，所以它的时间复杂度就为O(n)。
对数阶：
int count = 1;
while (count < n)
{
count = count * 2;
}上面这段代码，由于每次count乘以2之后，就距离n更近了一分。也就是说，有多少个2相乘后大于n，则会退出循环。由2^x=n得到x=log以2为底的n次方。所以这个循环的时间复杂度为O(logn)。
平方阶：
int i, j;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
}
}上面这段代码是一个嵌套循环，它的内层循环时间复杂度为O(n)；而对于外层的循环，不过是内部这个时间复杂度为O(n)的语句，再循环n次。所以这段代码的时间复杂度为O(n^2)。
如果外循环的循环次数改为了m，时间复杂度就变为O(m*n)。
int i, j;
for (i = 0; i < n; i++)
{
for (j = 0; j < m; j++)
{
}
}所以我们可以总结得出，循环的时间复杂度等于循环体的复杂度乘以该循环的运行次数。
那么下面这个循环嵌套，它的时间复杂度是多少呢？
int i, j;
for (i = 0; i < n; i++)
{
for (j = i; j < n; j++)
{
}
}由于当i = 0时，内循环执行了n次，当i = 1时执行了n-1次，······当i = n - 1时，执行了1次。所以总的执行次数为：
n + (n-1) + (n-2) +···+1 = n(n+1)/2 = n^2/2 + n/2
用我们推导大O阶的方法，第一条，没有加法常数不予考虑；第二条，只保留最高阶项，因此保留n^2/2；第三条，去除与这个项相乘的常数，也就是去除1/2，最终这段代码的时间复杂度为O(n^2)。
常见的时间复杂度如下表所示：
常用的时间复杂度所耗费的时间从小到大依次是：
O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)
2、空间复杂度
- 空间复杂度也是一个数学表达式，是一个算法在运行过程中临时占用存储空间大小的量度 。
- 空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。
- 空间复杂度计算规则基本跟时间复杂度类似，也使用大O渐进表示法。
注意：
函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候申请的额外空间来确定。
实例1：
// 计算BubbleSort的空间复杂度？
void BubbleSort(int* a, int n)
{
assert(a);
for (size_t end = n; end > 0; --end)
{
int exchange = 0;
for (size_t i = 1; i < end; ++i)
{
if (a[i - 1] > a[i])
{
Swap(&a[i - 1], &a[i]);
exchange = 1;
}
}
if (exchange == 0)
break;
}
}上面这段代码使用了常数个额外空间，所以空间复杂度为 O(1) 。
实例2：
// 计算Fibonacci的空间复杂度？
// 返回斐波那契数列的前n项
long long* Fibonacci(size_t n)
{
if (n == 0)
return NULL;
long long* fibArray = (long long*)malloc((n + 1) * sizeof(long long));
fibArray[0] = 0;
fibArray[1] = 1;
for (int i = 2; i <= n; ++i)
{
fibArray[i] = fibArray[i - 1] + fibArray[i - 2];
}
return fibArray;
}上面这段代码动态开辟了N个空间，空间复杂度为 O(N) 。
实例3：
// 计算阶乘递归Fac的空间复杂度？
long long Fac(size_t N)
{
if (N == 0)
return 1;
return Fac(N - 1) * N;
}上面这段代码递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间，所以空间复杂度为O(N) 。