文章介绍了衡量算法效率的两个重要指标——时间复杂度和空间复杂度，讲解了如何通过大O渐进表示法分析算法的时间复杂度，并通过多个案例分析了不同算法的时间和空间复杂度，包括斐波那契数列的实现以及排序算法等。此外，还提供了在线编程挑战（OJ）的解题示例，探讨了不同解法的时间复杂度。
目录
前言
在我们写的一个程序，越简洁就一定越好吗？如果不是，那该如何衡量该程序的好坏呢？这时候我们应该用算法复杂度去衡量，那什么是算法复杂度呢？接下来就让我们学习算法复杂度吧！从而正式进入数据结构的学习！
1.算法效率
1.1如何衡量一个算法的好坏
eg:
long long Fib(int N)
{
if (N < 3)
{
return 1;
}
return Fib(N - 1) + Fib(N - 2);
}
上面的代码为为斐波那契数列的实现方式，虽然简洁但不一定好。
1.2算法复杂度
算法在编写成可执行程序后，运行时需要耗费时间和空间资源（内存），因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度；时间复杂度是一个算法的运行快慢的重要量度，而空间复杂度一个算法运行所需要的额外空间。在计算机发展的早期，计算机的存储容量很小，那时候程序员把空间复杂很重要。但经过计算机行业的发展，计算机的存储容量已经达到很高的程度，所以我们已经不需要再特别关注一个算法的空间复杂度。🦀🦀🦀
2.时间复杂度
2.1时间复杂度的概念
时间复杂度的定义：算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上是算不出来的，但是一个算法所耗费的时间与语句的执行次数成正比例的，所以算法中的基本操作的执行次数为算法的时间复杂度，即：找到某条语句与问题规模之间的数学表达式，就是算出了该算法的时间复杂度。😾😾😾
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 = 20;
while (M--)
{
++count;
}
printf("%d\n", count);
}
int main()
{
Func1(10);
return 0;
}
实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，只需要计算大概执行次数，那么这里我们就要使用到大O渐进表示法。
2.2大O的渐进表示法
大O符号（Big O notation）: 是用于函数渐进行为的数学符号。🍭🍭🍭
推导大O阶级方法：
1.用常数1取代运行时间中的所有加法常数。
2.在修改后的运行次数中，只保留最高项。
3.如果最高项存在且不是1，则去除与该项相乘的常数，得到的结果就是大O阶。
使用大O阶渐进法以后，上面代码中Func1的时间复杂度为O(N^2)。
- N=10 F(N)=100
- N=100 F(N)=10000
- N=1000 F(N)=1000000
通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项。简洁明了的表示出执行的次数，另外有些算法存在最好、平均和最坏的情况： 🎉🎉🎉
最坏的情况：任意输入规模的最大运行次数（上界）。
平均情况：任意输入规模的期望运行次数。
最好的情况的最小运行次数（下界）。
例如：在一个长度为N的数组中搜素一个数据x
最坏的情况：1次找到
最坏的情况：N次找到
平均情况：N/2次找到
在实际中一般情况关注的是算法的最坏的情况，所以数组在搜索数据的时间复杂度为O(N)
2.3常见时间复杂度案例分析
eg1:
#include<stdio.h>
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);
}
int main()
{
Func2(100);
return 0;
}
解析： 上面的代码中执行了2N+10次，通过大O阶方法知道，只保留最高项，系数对结果的影响不大，所以该代码的时间复杂度为O(N)
eg2:
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);
}
解析： 上面的代码执行了M+N次，因为有两个未知数M和N，而且没有说明两个未知数谁远大于谁的情况，所以认定时间复杂度为O(M+N)；若是说明M远大于N，则时间复杂度为O(M)；若是说明N远大于M，则时间复杂度为O(N);若是M和N一样大，代码执行了2M(2N)次，时间复杂度为O(M)或O(N)。
eg3:
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; k++)
{
count++;
}
printf("%d\n", count);
}
解析： 实例3中执行了10次，通过大O阶方法，时间复杂度为O（1），在这里我们需要知道时间复杂度O（1）不是一次，而是常数次。
eg4:
const char* strchr(const char* str, int character)
{
while (*str)
{
if (*str == character)
{
return str;
}
++str;
}
}
解析： 实例4中最好的情况为1次，最坏的情况为N次，时间复杂度为最坏的情况，所以时间复杂度为O(N)。
eg5:
//计算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;
}
}
}
解析： 实例5的基本操作最好执行了N次，最坏执行了（N*（N+1））次，通过推导大O阶方法和时间复杂度一般是最坏的情况，时间复杂度为O(N^2)。
eg6:
//计算BinarySearch的时间复杂度
int BinarySearch(int* a, int n, int x)
{
assert(a);
int begin = 0;
int end = 0;
//[begin,end]:begin和end是左闭区间和右闭区间，因此有等号
while (begin <= end)
{
int mid = begin + ((end - begin) >> 1);
if (a[mid] > x)
begin = mid;
else if (a[mid] > x)
end = mid - 1;
else
return mid;
}
return -1;
}
解析： 最坏的情况：区间缩放到一个值时，要么找到，要么找不到；N/2/2/2/…/2=1，折半查找找多少次就除2，假设N是数组个数，x为查找的次数，2^x=N–>x=log2N；所以最好的时间复杂度为O(1)（即找一次就找到了）；最坏的情况为：O(logN)（因为log2N不好书写<以2为底数的对数>，所以我们可以把这个数化为logN，还有些地方会写成lgN，其他底数不能简写），所以算法时间复杂度O(logN)。
eg7：
long long Fac(size_t N)
{
if (0 == N)
return 1;
return Fac(N - 1) * N;
}
解析： 实例7通过计算分析发现基本操作递归N次，时间复杂度为O(N)。
eg8:
//计算斐波那契递归Fib的时间复杂度
long long Fib(size_t N)
{
if (N < 3)
return 1;
return Fib(N - 1) + Fib(N - 2);
}
图形理解：
解析： 实例8通过计算分析发现基本操作递归2^N次，时间复杂度为 O(2^N)
3.空间复杂度
时间复杂度也是一个数学表达式，对一个算法在运行过程中临时占用存储空间大小的量度。空间复杂度不是程序占用了多少字节，而是算变量的个数，同样也使用大O渐进表示法。
注意： 函数运行时所需要的站空间在编译期间已经确定好了，此空间复杂度主要通过函数在运行过程中申请的额外空间来确定。
//计算机BubbleSort的空间复杂
#include<stdio.h>
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;
}
}
}
解析： 函数开辟了end\exchange等常数个变量，系统使用开辟了常数个额外的空间，所以空间复杂度为O(1)。
eg2:
//计算Fibonacci的空间复杂度
//返回斐波那契数列的前n项
long long* Fibacci(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 = 0; i <= n; i++)
{
fibArray[1] = fibArray[i - 1] + fibArray[i - 2];
}
return fibArray;
}
解析： 实例2中用malloc函数动态开辟了N个空间，空间复杂度为O(N)。
eg3:
long long Fac(size_t N)
{
if (N == 0)
{
return 0;
}
return Fac(N - 1) + N;
}
解析： 实例3中函数递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间，空间复杂度为O(N)。
eg4:
void F1()
{
int a = 0;
printf("%p\n", &a);
}
void F2()
{
int b = 0;
printf("%p\n", &b);
}
#include<stdio.h>
int main()
{
F1();
F2();
return 0;
}//输出结果是什么？
代码运行的结果为：
解析： 由上面的代码可以看出，编译器在执行程序的时候，先为F1函数开辟空间，等F1函数执行完后，把空间还给操作系统后，才开始为F2函数分配栈帧空间，而不是同时为F1、F2函数开辟好函数空间才开始执行程序，所以F1\F2函数的地址都相同。
eg5:
//计算斐波那契数递归Fib的空间复杂度
long long Fib(size_t N)
{
if (N < 3)
return 1;
return Fib(N - 1) + Fib(N - 2);
}
图形理解：
解析： 理解了实例4也就不难理解实例5的情况了，操作系统为函数开辟N个栈帧，每个栈帧使用了常数个空间，空间复杂度为O(N)。
总结： 通过了上面时间复杂度和空间复杂度的学习，我们可以总结为：时间是一去不复返的，不可重复利用；空间用了归还以后，可以重复利用。 🐇🐇🐇
4.常见时间复杂度
一般算法常见的复杂度如下：
| 5201314 | O(1) | 常数阶 |
|---|---|---|
| 3n+4 | O(n) | 线性阶 |
| 3n^2+4n+5 | O(n^2) | 平方阶 |
| 3log(2)n+4 | O(logn) | 对数阶 |
| 2n+3nlog(2)+14 | O(nlogn) | nlogn阶 |
| n^3+2n ^2 +4n+6 | O(n^3) | 立方阶 |
| 2^n | O(2^n) | 指数阶 |
5.复杂度OJ练习
练习一：
解法一：
int missingNumber(int* nums, int numsSize)
{
int i = 0;
int sum = (0 + numsSize) * (numsSize + 1) / 2;
int sum1 = 0;
for (i = 0; i < numsSize; i++)
{
sum1 += nums[i];
}
sum = sum - sum1;
return sum;
}
#include<stdio.h>
int main()
{
int arr[6] = { 1,2,3,4,5 };
int ret = missingNumber(arr, 6);
printf("%d\n", ret);
return 0;
}
解法二：
int missingNumber(int* nums, int numsSize)
{
int i = 0;
int sum = 0;
for (i = 0; i < numsSize - 1; i++)
{
sum ^= nums[i];
}
for (i = 0; i < numsSize; i++)
{
sum ^= i;
}
return sum;
}
#include<stdio.h>
int main()
{
int arr[7] = { 0,1,2,3,4,5 };
int ret = missingNumber(arr, 7);
printf("%d\n", ret);
return 0;
}
解析： 解法一用等差数列的公式直接求出有序数组范围的和，减去有序数组的所有数的和后，最后剩下便是缺失的整数，该方法中用遍历的方法减去数组中的数，基本执行操作N次，时间复杂度为O(N)；解法二中，运用了异或运算符的性质，进行遍历，最后异或出来就是缺少的整数了，该方法基本执行操作2N次，根据大O渐进法时间复杂度为O(N)。
练习二：
解法一：
//逆置法
#include<stdio.h>
void revearse(int* src, int* dest)
{
int tmp = 0;
while (src < dest)
{
tmp = *src;
*src = *dest;
*dest = tmp;
src++;
dest--;
}
}
void rotate(int* nums, int numsSize, int k)
{
if (k > numsSize)
{
k %= numsSize;
}
//注意逆置下标位置
revearse(nums, nums + numsSize - k - 1);
revearse(nums + numsSize - k, nums + numsSize - 1);
revearse(nums, nums + numsSize - 1);
}
int main()
{
int nums[7] = { 1,2,3,4,5,6,7 };
int k = 3;
rotate(nums, 7, 3);
int i = 0;
for (i = 0; i < 7; i++)
{
printf("%d ", nums[i]);
}
return 0;
}
图形理解：
代码运行的结果为：
解法二：
//用空间换时间
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void rotate(int* nums, int numsSize, int k)
{
if (k > numsSize)
{
k %= numsSize;
}
int* tmp = (int*)malloc(numsSize * sizeof(int));
if (tmp == NULL)
{
perror("malloc");
return;
}
//控制好区间
memcpy(tmp, nums + numsSize - k, k * sizeof(int));
memcpy(tmp+k, nums, (numsSize-k) * sizeof(int));
memcpy(nums, tmp, numsSize * sizeof(int));
free(tmp);
tmp=NULL;
}
int main()
{
int nums[7] = { 1,2,3,4,5,6,7 };
int k = 3;
rotate(nums, 7, 3);
int i = 0;
for (i = 0; i < 7; i++)
{
printf("%d ", nums[i]);
}
return 0;
}
代码运行的结果为：
解法三：
//暴力匹配法
void rotate(int* nums, int numsSize, int k)
{
int i = 0;
for (i = 0; i < k; i++)
{
int tmp = nums[numsSize - 1];
//把除数组之外的数字往后移动
for (int end = numsSize - 2; end>=0;end--)
{
nums[end+1] = nums[end];
}
//一次逆置一个数字
nums[0] = tmp;
}
}
#include<stdio.h>
int main()
{
int nums[7] = { 1,2,3,4,5,6,7 };
int k = 3;
rotate(nums, 7, 3);
int i = 0;
for (i = 0; i < 7; i++)
{
printf("%d ", nums[i]);
}
return 0;
}
代码运行的结果为：
解析： 解法一先逆置前n-k个，执行了n-k次，然后逆置后面k个，执行了k次，最后整体逆置（n个），执行了n次，总的基本操作执行了2N次，根据大O渐进法，时间复杂度为O(N)；解法二类似解法一，把malloc函数开辟了N个空间的起始地址返回给tmp，先用memcpy拷贝数组后面k个到tmp前面，执行操作k次，然后用把数组前n-k个拷贝到tmp后面的位置，执行操作n次，最后把tmp中逆置的数再拷贝回数组，执行操作n次，总的基本操作执行了2N次；暴力匹配法，时间复杂为O(N^2)。
这两道oj题分别为消失的数字和旋转数组，大家感兴趣可以试一下。
总结
本章我们一起学习了数据结构中的时间复杂度和空间复杂度，知道了如何去判断一个算法、程序的好坏，希望本章内容对你了解时间复杂度和空间复杂度有些许帮助！最后感谢大家阅读，如有不对，欢迎纠正！🎠🎠🎠
扫一扫
1571
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
