目 录
如何衡量一个算法的好坏？是代码越简短就越好吗？接下来本文就将讨论衡量算法好坏的方法。
1 算法效率
算法在编成可执行程序后，运行时需要耗费时间资源和空间（内存）资源。因此，我们一般从时间和空间两个维度来衡量一个算法的好坏。对应的即是时间复杂度和空间复杂度。
时间复杂度主要衡量一个算法运行的快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。
在计算机发展的早期，计算的存储容量很小，所以很注重空间复杂度的大小。但是经过计算机行业的迅速发展 ，计算的存储容量已经达到了很高的程度，所以如今我们不再需要特别关注一个算法的空间复杂度。
值得一提的是：我们常常在各种刷题网站的题目中看到对解题算法的时间复杂度与空间复杂度的要求（如下图所示），且在许多面试中也常常被提问到有关算法的复杂度问题，可见学习算法的复杂度是非常有必要的。
2 复杂度
2.1 时间复杂度的概念
时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上是无法直接计算的，只有把程序放在机器上跑起来时才能知道。那难道我们需要将每个算法都上机测试一遍吗？这是可以，但显得麻烦了些。所以我们有了时间复杂度的分析方式。基于一个算法所花费的时间与其中语句的执行次数成正比例，因此以算法中基本操作的执行次数作为算法的时间复杂度。（即找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度）
那接下来我们先以一个例子来看看时间复杂度是如何计算的吧
// 请计算一下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中基本操作（++count）的执行次数（时间复杂度）：
● N = 10 F(N) = 130
● N = 100 F(N) = 10210
● N = 1000 F(N) = 1002010
实际中我们计算时间复杂度时，其实并不一定要计算精确的执行次数，而只需要知道大概执行次数。因此，我们使用大O渐进表示法来表示某个算法的基本操作的大概执行次数。
2.2 大O渐进表示法
大O符号（Big O notation）：用于描述函数渐进行为的数学符号。
推导大O阶方法：（估算：大概次数所属的量级）
①用常数1取代运行时间中的所有加法常数
②基于其它项对结果影响不大，在修改后的运行次数函数中，只保留最高阶项。
③如果最高阶项存在且不是1，则去除与这个项目相乘的常数（系数），得到的结果即为大O阶。
那我们看回到上面的例子，在使用大O渐进表示法以后，Func1的时间复杂度可以表示为：
此时：
● N = 10 F(N) = 100
● N = 100 F(N) = 10000
● N = 1000 F(N) = 1000000
可以发现：使用大O渐进表示法去掉那些对结果影响不大的项后，表示出的时间复杂度更加简洁明了。
此外有些算法的时间复杂度有最好、平均和最坏情况之分：
●最坏情况：任意输入规模的最大运行次数（上界）
●平均情况：任意输入规模的平均（期望）运行次数
●最好情况：任意输入规模的最小运行次数（下界）
例如在一个长度为N的数组中搜索一个数据：
●最坏情况：N次找到
●平均情况：N/2次找到
●最好情况：1次找到
在实际情况中，我们一般关注的是算法的最坏运行情况，所以在长度为N的数组中搜索数据的时间复杂度为O(N)
2.3 空间复杂度概念
空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度
空间复杂度并不是指程序占用了多少字节的空间，空间复杂度关注的是变量的个数。与时间复杂度的表示规则类似，空间复杂度也采用大O渐进表示法。
需要注意的是：函数运行时所需要的栈空间（存储参数、局部变量、一些寄存器信息等）在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。
3 时间复杂度与空间复杂度的计算练习
了解了时间复杂度与空间复杂度的基本概念和表示方法后，接下来我们通过一些实例练习来加深理解。
3.1 时间复杂度计算练习
🍚实例1：
// 计算Func2的时间复杂度
void Func2(int N)
{
int count = 0;
for (int k = 0; k < 2 * N ; ++ k)
{
++count;
}
int M = 10;
while (M–)
{
++count;
}
printf(“%d\n”, count);
}
分析：在函数Func2中for循环的循环体一共执行2 * N次，while循环的循环体一共执行M（10）次，因此函数中基本操作的执行次数为：2*N + 10，使用大O渐进表示法表示，则该函数的时间复杂度为O(N)
🍚实例2：
// 计算Func3的时间复杂度
void Func3(int N, int M)
{
int count = 0;
for (int k = 0; k < M; ++ k)
{
++count;
}
for (int k = 0; k < N ; ++ k)
{
++count;
}
printf(“%d\n”, count);
}
分析：在函数Func3中第一个for循环的循环体一共执行M次，第二个for循环的循环体一共执行N次，因此函数中基本操作的执行次数为：M + N，使用大O渐进表示法表示，则该函数的时间复杂度为O(M + N)
🍚实例3：
// 计算Func4的时间复杂度
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++ k)
{
++count;
}
printf(“%d\n”, count);
}
分析：在函数Func4中，不论输入的N为多大，for循环的循环体固定执行100次（即为常数次，无关输入），则使用大O渐进表示法表示，该函数的时间复杂度为O(1)
🍚实例4：
// 计算strchr的时间复杂度
//搜索字符character在str所指向的字符串中第一次出现的位置
const char * strchr ( const char * str, int character );
分析：假设字符串长度为N，顺序搜索字符串，最好的情况下，要搜索的字符就在字符串的第一个位置，即只寻找一次就找到目标；平均情况下，要搜索字符位于字符串中间位置，即搜索次数为N/2；最坏情况下，要搜索的字符在字符串的最后一个位置，搜索次数为N次，即最坏情况下时间复杂度为O(N)
🍚实例5：
// 计算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(N^2)，那实际是否是这样呢？让我们从冒泡排序的原理出发：每进行一趟排序就将当前排序数里的最大数放到最后，每排完一趟，下一趟的排序数就少一个，这样逐次将大的数往后放，直到只剩一个排序数则排序完成。则假设要对长度为N的数组进行排序（最坏情况下）：
| 趟数 | 排序次数 |
|---|---|
| 第一趟 | N - 1 |
| 第二趟 | N - 2 |
| … | … |
| 最后一趟 | 1 |
最坏情况下需要排N - 1趟，可见上述排序次数构成了一个等差数列，求和：1 + 2 + … + N - 1 = N*(N-1) / 2，即最坏情况下需排序N*(N-1) / 2次，用大O渐进法（保留最高阶项，去掉系数）表示冒泡排序算法的时间复杂度为O(N^2)
🍚实例6：
// 计算BinarySearch的时间复杂度
int BinarySearch(int* a, int n, int x)
{
assert(a);
int begin = 0;
int end = n-1;
// [begin, end]：begin和end是左闭右闭区间，因此有=号
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的有序数组中查找数x，如下图所示，假设所需查找的数为1，即数组第一个元素，每次将目标与查找空间的中间元素进行比较，（升序数组中）如果目标元素比中间元素要小，则将查找空间缩小到当前查找空间的前半部分空间，反之，则缩小到后半部分空间。每次查找过后，查找空间大小都将缩小为上一次空间的一半，最坏情况下，当查找空间中只剩一个元素时才找到目标，或者数组中没有目标元素。
基于此，假设最坏情况下的查找次数为y，则存在关系：2^y = N，可推出查找次数：y = log2(N) (表示以2为底N的对数)
即用大O渐进表示法表示二分查找算法的时间复杂度为：O( log2(N))，考虑到二分思想使用的高频性和复杂度表示的简便性，通常可以忽略时间复杂度表示中以2为底的对数的底数2，即可写成：O(log(N))，但若有以其它数为底的情况，此时底数不能省略，需要完整表示出来。
🍚实例7：
// 计算阶乘递归Fac的时间复杂度
long long Fac(size_t N)
{
if(0 == N)
return 1;
return Fac(N-1)*N;
}
分析：计算阶乘递归的函数的时间复杂度，相当于计算输入为N时函数被调用了多少次，如下图所示，只有当N = 0时函数才结束递出开始返回，函数被调用了N + 1次，即递归了N次，用大O渐进表示法表示时间复杂度为：O(N)
🍚实例8：
// 计算斐波那契递归Fib的时间复杂度
long long Fib(size_t N)
{
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}
分析：如下图所示，斐波那契递归示意图类似于二叉树结构，使用大O渐进表示法表示时间复杂度时，我们只需要计算函数基本操作执行的大概次数（或者是函数被调用的大概次数），忽略对结果影响不大的误差，将递归示意结构视为满二叉树，从第一层开始计算，每层递归函数被调用2^(N-1)次，可以发现每层函数被调用次数成等比数列，对其进行求和有：
20 + 21 + …… + 2(N-2) = 2(N-1) - 1
则时间复杂度为：O(2^N)
3.2 空间复杂度计算练习
🍚实例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;
}
}
分析：除函数已有的参数a和n外，在函数中只额外定义了end、exchange、i这三个变量，即只为这三个临时变量申请了额外的空间，不论输入为多少，额外申请的空间是固定大小的，即为常数，根据大O渐进表示法，则该函数的空间复杂度为：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项，因此在调用函数时只会开辟一块函数栈帧，而除函数已有的参数外，函数中还定义了变量i，并且动态开辟了(n+1) 块大小为sizeof(long long)字节的额外的内存空间，额外开辟的空间数量与输入n有关，则可推出该函数算法的空间复杂度为：O(N)
🍚实例3：
// 计算阶乘递归Fac的空间复杂度
long long Fac(size_t N)
{
if(N == 0)
return 1;
return Fac(N-1)*N;
}
分析：当函数被调用时，会在栈空间中创建一块函数栈帧，当函数返回或者调用结束时对应的函数栈帧就会自动销毁。如下图所示，调用阶乘递归函数求N的阶乘，第一次调用函数时创建的函数栈帧不算作额外申请的空间，而因为只有当N取得0时，函数才结束递归开始返回，直到返回前，调用的函数栈帧都不会被销毁，又因递归会在原函数栈帧的基础上继续开辟新的函数栈帧，此时开辟的函数栈帧即算作额外的申请空间。则表示：当输入为N时，函数需额外开辟N个函数栈帧，每个函数栈帧使用了常数个空间，因此根据大O渐进表示法，该函数算法的空间复杂度为：O(N)
4 常见复杂度对比
一般算法的常见复杂度如下：
| 531354 | O(1) | 常数阶 |
|---|---|---|
| 2N+1 | O(N) | 线性阶 |
| 3N2+4N+5 | O(N2) | 平方阶 |
| 3log2(N)+4 | O(log(N)) | 对数阶 |
| 2N+3Nlog2(N)+14 | O(Nlog(N)) | Nlog(N)阶 |
| N3+2N2+4N+6 | O(N3) | 立方阶 |
| 2N | O(2N) | 指数阶 |
| N! | O(N!) | 阶乘阶 |
总结
回顾文章开头，关于如何衡量一个算法的好坏？这个问题我想文中已经给出了答案，至于是否代码越简短就越好？通过文中的一些练习，我们可以发现，看着简短的代码有时复杂度也很高，而层层嵌套的代码不一定复杂度就高。因此，要想真正了解一个算法的好坏，不能仅凭第一眼直觉判断，还需根据实际情况进行算法复杂度的分析计算。
以上是我对算法的时间复杂度和空间复杂度的一些学习记录总结，如有错误，希望大家帮忙指正，也欢迎大家给予建议和讨论，谢谢！
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
