小白也爱看的初阶数据结构2

上一篇文章我们具体讲了大（O）的渐进表示法，也知道了时间复杂度的表示应该只留下数量级来代表他的大小，具体的我们这篇文章来讲。

test1

// 计算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);
}

这里我们数得出来基本操作执行了2N+10次，通过推导大O阶方法知道，时间复杂度为 O(N)。

test2

// 计算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);
}

基本操作执行了M+N次，有两个未知数M和N，时间复杂度为 O(N+M)

test3

// 计算Func4的时间复杂度？
void Func4(int N)
{
 int count = 0;
 for (int k = 0; k < 100; ++ k)
 {
 ++count;
 }
 printf("%d\n", count);
}

基本操作执行了10次，通过推导大O阶方法，时间复杂度为 O(1).

注意，只要是实数次那就是o（1）.如果有未知数次，那就是o（n）那些。

test4

// 计算strchr的时间复杂度？
const char * strchr ( const char * str, int character );

在这里strchr 函数的时间复杂度取决于字符串的长度和字符在字符串中的位置。

也就是说最坏情况时间复杂度：O(n)
最好情况时间复杂度：O(1)     我第一个就是要找的字符，那么就结束了。
平均情况时间复杂度：O(n)

test5

// 计算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;
 }
}

这里冒泡排序基本操作执行最好N次，最坏执行了(N*(N+1)/2次，通过推导大O阶方法+时间复杂度一般看最坏，时间复杂度为 O(N^2)。

test6

// 计算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;
 else
 return mid;
 }
 
 return -1;
}

这里基本操作执行最好1次，最坏O(logN)次，时间复杂度为 O(logN) ps：logN在算法分析中表示是底数为2，对数为N。有些地方会写成lgN。

test7

// 计算阶乘递归Fac的时间复杂度？
long long Fac(size_t N)
{
 if(0 == N)
 return 1;
 
 return Fac(N-1)*N;
}

时间复杂度为O(N)。这里很明显就是一次次的递归知道

每次递归调用 Fac(N-1)，直到 N 递减到 0 时终止。

总共有 N+1 次调用（从 Fac(N) 到 Fac(0)），但时间复杂度通常关注 递归深度，即需要执行的操作次数。

每次递归中，除了终止条件外，只执行一次乘法操作（Fac(N-1)*N），时间复杂度为 O(1)。

每次递归执行一次乘法操作，总共执行 N 次乘法。

所以是O(N).

test8

// 计算斐波那契递归Fib的时间复杂度？
long long Fib(size_t N)
{
 if(N < 3)
 return 1;
 
 return Fib(N-1) + Fib(N-2);
}

基本操作递归了2^N次，时间复杂度为O(2^N)。

这里可以自己尝试画一下递推树的模型。

     Fib(5)
     /   \
 Fib(4)  Fib(3)
 /   \     /   \

递归调用的总次数实际上形成了一个指数级的增长。具体来说，递归调用的次数与斐波那契数列的项数有关。我们可以看到，每个 Fib(N) 会生成大约 2^N 个递归调用。

那接下来我们汇总一下复杂度的表示

常见的有：

对应的增长速度是这样。了解一下就可以

空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度 。

空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。

空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。

注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

而且我们也说了，空间复杂度现在不太关注，悄悄告诉你：

现在空间复杂度基本上都是O（1）或者O(N),O(n^2)的情况也有，也就出现二维数组里面，其他很少见。不用过多在意。

我们来看一个最典型的例子，还是刚刚那个递归：

// 计算阶乘递归Fac的空间复杂度？
long long Fac(size_t N)
{
 if(N == 0)
 return 1;
 
 return Fac(N-1)*N;
}

递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)。

什么意思呢？

每次递归调用 Fac(N-1) 都会在调用栈上创建一个新的栈帧。
栈帧中存储了当前的参数 N 和可能的局部变量。
递归调用的深度为 N + 1，因为从 N 递归到 0 需要 N + 1 次调用。

每个栈帧占用的空间是常数级别的，即 O(1)。

我们照样画一下递归树来实现

Fac(N)
  |
  v
Fac(N-1) * N
  |
  v
Fac(N-2) * (N-1)
  |
  v
  ...
  |
  v
Fac(1) * 2
  |
  v
Fac(0) * 1
  |
  v
  1

相当于栈帧是一层一层调用的。最后开辟了N个栈帧，那不就是O（N）了吗。

好了，讲到这里复杂度基本都讲完了，下一篇文章我们就来讲解顺序表，如果你看到了这里，那你真的很棒。如果你觉得对你有帮助，可以点赞关注加收藏，感谢您的阅读，我们下一篇文章再见。